diff options
| author | Andrew Reynolds <andrew.j.reynolds@gmail.com> | 2018-02-15 15:31:48 -0600 |
|---|---|---|
| committer | Aina Niemetz <aina.niemetz@gmail.com> | 2018-02-15 13:31:48 -0800 |
| commit | 55037e0bcef45c795f28ff3fcf6c1055af465c70 (patch) | |
| tree | 397d89bd10e541e1206c5dafdb8cf731feb34730 /test/regress/regress1 | |
| parent | 52a39aca19b7238d08c3cebcfa46436a73194008 (diff) | |
Refactor regressions (#1581)
Diffstat (limited to 'test/regress/regress1')
638 files changed, 39673 insertions, 813 deletions
diff --git a/test/regress/regress1/Makefile.am b/test/regress/regress1/Makefile.am index 9bf23f555..af3f65370 100644 --- a/test/regress/regress1/Makefile.am +++ b/test/regress/regress1/Makefile.am @@ -1,4 +1,4 @@ -SUBDIRS = . bv aufbv auflia datatypes rewriterules lemmas decision fmf nl strings sets sygus sep quantifiers +SUBDIRS = . arith bv aufbv auflia datatypes rewriterules lemmas decision fmf ho nl push-pop quantifiers rels strings sets sygus sep uflia # don't override a BINARY imported from a personal.mk @mk_if@eq ($(BINARY),) @@ -20,11 +20,54 @@ MAKEFLAGS = -k # These are run for all build profiles. # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" -TESTS = bug425.cvc \ - bug519.smt2 \ - bug521.smt2 - -EXTRA_DIST = $(TESTS) +TESTS = \ + bug425.cvc \ + bug519.smt2 \ + bug521.smt2 \ + bug694-Unapply1.scala-0.smt2 \ + fmf-fun-dbu.smt2 \ + bug296.smt2 \ + bug507.smt2 \ + gensys_brn001.smt2 \ + simplification_bug4.smt2 \ + trim.cvc \ + constarr3.cvc \ + constarr3.smt2 \ + parsing_ringer.cvc \ + arrayinuf_error.smt2 \ + boolean-terms-kernel2.smt2 \ + boolean.cvc \ + bug216.smt2 \ + bug512.smt2 \ + bug516.smt2 \ + bug520.smt2 \ + bug543.smt2 \ + bug567.smt2 \ + bug593.smt2 \ + bug681.smt2 \ + bug800.smt2 \ + bvdiv2.smt2 \ + error.cvc \ + errorcrash.smt2 \ + hole6.cvc \ + ite5.smt2 \ + non-fatal-errors.smt2 \ + proof00.smt2 \ + sqrt2-sort-inf-unk.smt2 \ + test12.cvc \ + uf2.smt2 + +EXTRA_DIST = $(TESTS) \ + simplification_bug4.smt2.expect \ + bug590.smt2.expect \ + bug216.smt2.expect \ + bug590.smt2 \ + bug585.cvc \ + crash_burn_locusts.smt2 \ + bug472.smt2 \ + simple-rdl-definefun.smt2 + +# issue1048-arrays-int-real.smt2 -- different errors on debug and production # synonyms for "check" in this directory .PHONY: regress regress1 test diff --git a/test/regress/regress1/arith/Makefile.am b/test/regress/regress1/arith/Makefile.am new file mode 100644 index 000000000..e2b0e93d9 --- /dev/null +++ b/test/regress/regress1/arith/Makefile.am @@ -0,0 +1,139 @@ +# don't override a BINARY imported from a personal.mk +@mk_if@eq ($(BINARY),) +@mk_empty@BINARY = cvc4 +end@mk_if@ + +LOG_COMPILER = @srcdir@/../../run_regression +AM_LOG_FLAGS = $(RUN_REGRESSION_ARGS) @abs_top_builddir@/src/main/$(BINARY)$(EXEEXT) + +if AUTOMAKE_1_11 +# old-style (pre-automake 1.12) test harness +TESTS_ENVIRONMENT = \ + $(LOG_COMPILER) \ + $(AM_LOG_FLAGS) $(LOG_FLAGS) +endif + +# These are run for all build profiles. +# If a test shouldn't be run in e.g. competition mode, +# put it below in "TESTS +=" +TESTS = \ + arith-int-004.cvc \ + arith-int-011.cvc \ + arith-int-048.cvc \ + arith-int-050.cvc \ + arith-int-084.cvc \ + arith-int-085.cvc \ + arith-int-097.cvc \ + bug716.0.smt2 \ + problem__003.smt2 \ + bug547.1.smt2 \ + bug716.1.cvc \ + div.03.smt2 \ + div.06.smt2 \ + div.08.smt2 \ + div.09.smt2 \ + miplib3.cvc \ + mod.02.smt2 \ + mod.03.smt2 \ + mult.02.smt2 \ + arith-int-012.cvc \ + arith-int-013.cvc \ + arith-int-022.cvc \ + arith-int-024.cvc \ + arith-int-047.cvc + +EXTRA_DIST = $(TESTS) \ + arith-int-008.cvc \ + arith-int-018.cvc \ + arith-int-020.cvc \ + arith-int-026.cvc \ + arith-int-029.cvc \ + arith-int-030.cvc \ + arith-int-043.cvc \ + arith-int-044.cvc \ + arith-int-049.cvc \ + arith-int-061.cvc \ + arith-int-062.cvc \ + arith-int-064.cvc \ + arith-int-065.cvc \ + arith-int-081.cvc \ + arith-int-083.cvc \ + arith-int-090.cvc \ + arith-int-091.cvc \ + arith-int-092.cvc \ + arith-int-094.cvc \ + arith-int-096.cvc \ + arith-int-098.cvc \ + arith-int-001.cvc \ + arith-int-002.cvc \ + arith-int-003.cvc \ + arith-int-005.cvc \ + arith-int-006.cvc \ + arith-int-009.cvc \ + arith-int-010.cvc \ + arith-int-016.cvc \ + arith-int-017.cvc \ + arith-int-019.cvc \ + arith-int-027.cvc \ + arith-int-028.cvc \ + arith-int-031.cvc \ + arith-int-032.cvc \ + arith-int-033.cvc \ + arith-int-034.cvc \ + arith-int-035.cvc \ + arith-int-036.cvc \ + arith-int-037.cvc \ + arith-int-038.cvc \ + arith-int-039.cvc \ + arith-int-040.cvc \ + arith-int-041.cvc \ + arith-int-045.cvc \ + arith-int-046.cvc \ + arith-int-051.cvc \ + arith-int-052.cvc \ + arith-int-053.cvc \ + arith-int-054.cvc \ + arith-int-055.cvc \ + arith-int-056.cvc \ + arith-int-057.cvc \ + arith-int-058.cvc \ + arith-int-059.cvc \ + arith-int-060.cvc \ + arith-int-063.cvc \ + arith-int-066.cvc \ + arith-int-067.cvc \ + arith-int-068.cvc \ + arith-int-069.cvc \ + arith-int-070.cvc \ + arith-int-071.cvc \ + arith-int-072.cvc \ + arith-int-073.cvc \ + arith-int-074.cvc \ + arith-int-075.cvc \ + arith-int-076.cvc \ + arith-int-077.cvc \ + arith-int-078.cvc \ + arith-int-080.cvc \ + arith-int-086.cvc \ + arith-int-087.cvc \ + arith-int-088.cvc \ + arith-int-089.cvc \ + arith-int-093.cvc \ + arith-int-095.cvc \ + arith-int-099.cvc \ + arith-int-100.cvc + +FAILING_TESTS = \ + arith-int-007.cvc \ + arith-int-082.cvc \ + arith-int-098.cvc + +EXTRA_DIST = $(TESTS) + +# synonyms for "check" in this directory +.PHONY: regress regress1 test +regress regress1 test: check + +# do nothing in this subdir +.PHONY: regress0 regress2 regress3 regress4 +regress0 regress2 regress3 regress4: diff --git a/test/regress/regress1/arith/arith-int-001.cvc b/test/regress/regress1/arith/arith-int-001.cvc new file mode 100644 index 000000000..03ed1a6ae --- /dev/null +++ b/test/regress/regress1/arith/arith-int-001.cvc @@ -0,0 +1,14 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-23 * x0) + (-23 * x1) + (5 * x2) + (-17 * x3) = 7 ; +ASSERT (-14 * x0) + (-14 * x1) + (19 * x2) + (-24 * x3) = 29 ; +ASSERT (-16 * x0) + (-17 * x1) + (8 * x2) + (4 * x3) > -10 ; +ASSERT (6 * x0) + (-10 * x1) + (-22 * x2) + (-22 * x3) >= 0 ; +ASSERT (18 * x0) + (0 * x1) + (27 * x2) + (7 * x3) <= -2 ; +ASSERT (-23 * x0) + (27 * x1) + (24 * x2) + (-23 * x3) > -25 ; +ASSERT (3 * x0) + (32 * x1) + (15 * x2) + (-21 * x3) >= -10 ; +ASSERT (-27 * x0) + (-16 * x1) + (21 * x2) + (-2 * x3) < 30 ; +ASSERT (-25 * x0) + (-18 * x1) + (-23 * x2) + (22 * x3) < -15 ; +ASSERT (-20 * x0) + (0 * x1) + (4 * x2) + (-26 * x3) >= 15 ; +ASSERT (-8 * x0) + (32 * x1) + (9 * x2) + (17 * x3) > -26; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-002.cvc b/test/regress/regress1/arith/arith-int-002.cvc new file mode 100644 index 000000000..849daba79 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-002.cvc @@ -0,0 +1,14 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (17 * x0) + (-23 * x1) + (2 * x2) + (-19 * x3) = -18 ; +ASSERT (25 * x0) + (23 * x1) + (21 * x2) + (20 * x3) = 2 ; +ASSERT (-24 * x0) + (-30 * x1) + (-14 * x2) + (13 * x3) <= 15 ; +ASSERT (-26 * x0) + (7 * x1) + (8 * x2) + (14 * x3) <= 16 ; +ASSERT (-1 * x0) + (-3 * x1) + (-19 * x2) + (26 * x3) <= -15 ; +ASSERT (31 * x0) + (19 * x1) + (-19 * x2) + (24 * x3) < -25 ; +ASSERT (8 * x0) + (-27 * x1) + (22 * x2) + (-20 * x3) < -30 ; +ASSERT (25 * x0) + (7 * x1) + (-18 * x2) + (-18 * x3) >= -31 ; +ASSERT (7 * x0) + (-22 * x1) + (-8 * x2) + (-6 * x3) >= -17 ; +ASSERT (-23 * x0) + (14 * x1) + (23 * x2) + (22 * x3) > -29 ; +ASSERT (-6 * x0) + (-6 * x1) + (-19 * x2) + (-4 * x3) > -5; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-003.cvc b/test/regress/regress1/arith/arith-int-003.cvc new file mode 100644 index 000000000..9c060c469 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-003.cvc @@ -0,0 +1,14 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (17 * x0) + (-7 * x1) + (15 * x2) + (21 * x3) = 19 ; +ASSERT (6 * x0) + (-24 * x1) + (25 * x2) + (-18 * x3) > -25 ; +ASSERT (-26 * x0) + (-28 * x1) + (-23 * x2) + (0 * x3) < -14 ; +ASSERT (-12 * x0) + (16 * x1) + (26 * x2) + (-23 * x3) <= 11 ; +ASSERT (14 * x0) + (6 * x1) + (9 * x2) + (-29 * x3) > 24 ; +ASSERT (5 * x0) + (-10 * x1) + (21 * x2) + (-26 * x3) > -12 ; +ASSERT (31 * x0) + (6 * x1) + (30 * x2) + (10 * x3) <= -25 ; +ASSERT (-18 * x0) + (-25 * x1) + (-24 * x2) + (-30 * x3) >= -18 ; +ASSERT (29 * x0) + (25 * x1) + (29 * x2) + (-31 * x3) < 6 ; +ASSERT (21 * x0) + (-27 * x1) + (-28 * x2) + (-15 * x3) >= 25 ; +ASSERT (-13 * x0) + (10 * x1) + (-7 * x2) + (-10 * x3) <= -4; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-004.cvc b/test/regress/regress1/arith/arith-int-004.cvc new file mode 100644 index 000000000..314b76d18 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-004.cvc @@ -0,0 +1,15 @@ +% EXPECT: invalid + +x0, x1, x2, x3 : INT; +ASSERT (12 * x0) + (-25 * x1) + (21 * x2) + (7 * x3) < 27 ; +ASSERT (9 * x0) + (2 * x1) + (26 * x2) + (-3 * x3) >= 11 ; +ASSERT (3 * x0) + (-29 * x1) + (-4 * x2) + (-17 * x3) > 2 ; +ASSERT (7 * x0) + (-29 * x1) + (12 * x2) + (16 * x3) >= -14 ; +ASSERT (21 * x0) + (32 * x1) + (16 * x2) + (4 * x3) >= -19 ; +ASSERT (6 * x0) + (23 * x1) + (-10 * x2) + (-25 * x3) > 5 ; +ASSERT (-26 * x0) + (4 * x1) + (-23 * x2) + (-30 * x3) >= 25 ; +ASSERT (-4 * x0) + (-13 * x1) + (15 * x2) + (-12 * x3) > -13 ; +ASSERT (-11 * x0) + (31 * x1) + (0 * x2) + (-2 * x3) < 8 ; +ASSERT (7 * x0) + (14 * x1) + (-21 * x2) + (-5 * x3) >= -19 ; +ASSERT (-28 * x0) + (-12 * x1) + (7 * x2) + (-5 * x3) <= 28; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-005.cvc b/test/regress/regress1/arith/arith-int-005.cvc new file mode 100644 index 000000000..9b9776ad3 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-005.cvc @@ -0,0 +1,14 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (13 * x0) + (0 * x1) + (6 * x2) + (-30 * x3) = -16 ; +ASSERT (-4 * x0) + (-8 * x1) + (14 * x2) + (-8 * x3) = -11 ; +ASSERT (-23 * x0) + (-26 * x1) + (4 * x2) + (-6 * x3) <= -2 ; +ASSERT (-22 * x0) + (-18 * x1) + (-23 * x2) + (5 * x3) < -32 ; +ASSERT (27 * x0) + (-12 * x1) + (-19 * x2) + (-17 * x3) <= -29 ; +ASSERT (12 * x0) + (21 * x1) + (-22 * x2) + (15 * x3) > 4 ; +ASSERT (-15 * x0) + (16 * x1) + (2 * x2) + (-14 * x3) >= -26 ; +ASSERT (4 * x0) + (4 * x1) + (-21 * x2) + (10 * x3) >= -6 ; +ASSERT (-6 * x0) + (25 * x1) + (-14 * x2) + (8 * x3) >= -31 ; +ASSERT (-23 * x0) + (2 * x1) + (-9 * x2) + (19 * x3) <= 10 ; +ASSERT (21 * x0) + (24 * x1) + (14 * x2) + (-6 * x3) <= 0; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-006.cvc b/test/regress/regress1/arith/arith-int-006.cvc new file mode 100644 index 000000000..999b4a5b4 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-006.cvc @@ -0,0 +1,10 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-7 * x0) + (-28 * x1) + (8 * x2) + (29 * x3) = -18 ; +ASSERT (11 * x0) + (2 * x1) + (4 * x2) + (23 * x3) = 6 ; +ASSERT (24 * x0) + (-20 * x1) + (23 * x2) + (-2 * x3) = 19 ; +ASSERT (17 * x0) + (-6 * x1) + (2 * x2) + (-22 * x3) = -31 ; +ASSERT (16 * x0) + (-7 * x1) + (27 * x2) + (17 * x3) = -8; +ASSERT (-5 * x0) + (18 * x1) + (3 * x2) + (-1 * x3) <= 29 ; +ASSERT (9 * x0) + (29 * x1) + (30 * x2) + (23 * x3) >= 21 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-007.cvc b/test/regress/regress1/arith/arith-int-007.cvc new file mode 100644 index 000000000..4cb4d88ef --- /dev/null +++ b/test/regress/regress1/arith/arith-int-007.cvc @@ -0,0 +1,10 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-19 * x0) + (17 * x1) + (30 * x2) + (-31 * x3) <= -20 ; +ASSERT (-3 * x0) + (16 * x1) + (20 * x2) + (-25 * x3) < 28 ; +ASSERT (11 * x0) + (13 * x1) + (-15 * x2) + (-8 * x3) <= 18 ; +ASSERT (-21 * x0) + (0 * x1) + (32 * x2) + (7 * x3) > -31 ; +ASSERT (16 * x0) + (24 * x1) + (8 * x2) + (23 * x3) <= 16 ; +ASSERT (25 * x0) + (-11 * x1) + (-8 * x2) + (14 * x3) <= 17 ; +ASSERT (16 * x0) + (-25 * x1) + (-1 * x2) + (13 * x3) < -26; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-008.cvc b/test/regress/regress1/arith/arith-int-008.cvc new file mode 100644 index 000000000..1ae22c993 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-008.cvc @@ -0,0 +1,10 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-12 * x0) + (-15 * x1) + (-31 * x2) + (17 * x3) = -16 ; +ASSERT (11 * x0) + (-5 * x1) + (-8 * x2) + (-17 * x3) > -4 ; +ASSERT (-12 * x0) + (-22 * x1) + (9 * x2) + (-20 * x3) >= 32 ; +ASSERT (24 * x0) + (-32 * x1) + (5 * x2) + (31 * x3) > 20 ; +ASSERT (-30 * x0) + (-4 * x1) + (-4 * x2) + (0 * x3) >= -20 ; +ASSERT (-10 * x0) + (18 * x1) + (17 * x2) + (20 * x3) <= 30 ; +ASSERT (12 * x0) + (-13 * x1) + (4 * x2) + (-27 * x3) > 3; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-009.cvc b/test/regress/regress1/arith/arith-int-009.cvc new file mode 100644 index 000000000..9bd7a2ce4 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-009.cvc @@ -0,0 +1,10 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-16 * x0) + (-21 * x1) + (32 * x2) + (32 * x3) = -19 ; +ASSERT (-10 * x0) + (-21 * x1) + (13 * x2) + (-7 * x3) = 2 ; +ASSERT (11 * x0) + (15 * x1) + (-8 * x2) + (-24 * x3) = 29 ; +ASSERT (3 * x0) + (-28 * x1) + (-14 * x2) + (-18 * x3) < 5 ; +ASSERT (-18 * x0) + (-13 * x1) + (25 * x2) + (22 * x3) <= -24 ; +ASSERT (-16 * x0) + (-17 * x1) + (-27 * x2) + (4 * x3) >= -5 ; +ASSERT (21 * x0) + (13 * x1) + (20 * x2) + (-1 * x3) < 19; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-010.cvc b/test/regress/regress1/arith/arith-int-010.cvc new file mode 100644 index 000000000..4ac85a984 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-010.cvc @@ -0,0 +1,10 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (19 * x0) + (-2 * x1) + (-29 * x2) + (-24 * x3) = 3 ; +ASSERT (3 * x0) + (11 * x1) + (-14 * x2) + (6 * x3) = 4 ; +ASSERT (-1 * x0) + (-22 * x1) + (4 * x2) + (5 * x3) = -22; +ASSERT (8 * x0) + (-8 * x1) + (18 * x2) + (-14 * x3) < -20 ; +ASSERT (22 * x0) + (27 * x1) + (6 * x2) + (-3 * x3) <= -11 ; +ASSERT (-23 * x0) + (-29 * x1) + (-27 * x2) + (13 * x3) <= 3 ; +ASSERT (8 * x0) + (0 * x1) + (28 * x2) + (0 * x3) >= -29 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-011.cvc b/test/regress/regress1/arith/arith-int-011.cvc new file mode 100644 index 000000000..bd2fa2a0d --- /dev/null +++ b/test/regress/regress1/arith/arith-int-011.cvc @@ -0,0 +1,5 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (13 * x0) + (-1 * x1) + (11 * x2) + (10 * x3) = 9 ; +ASSERT (-7 * x0) + (3 * x1) + (-22 * x2) + (16 * x3) >= 9; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-012.cvc b/test/regress/regress1/arith/arith-int-012.cvc new file mode 100644 index 000000000..11b0dab27 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-012.cvc @@ -0,0 +1,5 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (18 * x0) + (32 * x1) + (-11 * x2) + (18 * x3) < -25 ; +ASSERT (-31 * x0) + (16 * x1) + (24 * x2) + (9 * x3) >= -24; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-013.cvc b/test/regress/regress1/arith/arith-int-013.cvc new file mode 100644 index 000000000..329251cae --- /dev/null +++ b/test/regress/regress1/arith/arith-int-013.cvc @@ -0,0 +1,5 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-22 * x0) + (-14 * x1) + (4 * x2) + (-12 * x3) > 25 ; +ASSERT (14 * x0) + (11 * x1) + (32 * x2) + (-8 * x3) >= 2; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-016.cvc b/test/regress/regress1/arith/arith-int-016.cvc new file mode 100644 index 000000000..6774dd2d1 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-016.cvc @@ -0,0 +1,20 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-13 * x0) + (-4 * x1) + (-20 * x2) + (-26 * x3) = 2 ; +ASSERT (13 * x0) + (13 * x1) + (-14 * x2) + (26 * x3) = -8 ; +ASSERT (-13 * x0) + (1 * x1) + (16 * x2) + (4 * x3) = -22 ; +ASSERT (17 * x0) + (7 * x1) + (32 * x2) + (19 * x3) = 16 ; +ASSERT (11 * x0) + (-8 * x1) + (-10 * x2) + (-10 * x3) <= -1 ; +ASSERT (-25 * x0) + (-18 * x1) + (-10 * x2) + (-19 * x3) <= 32 ; +ASSERT (0 * x0) + (-14 * x1) + (30 * x2) + (-5 * x3) > -13 ; +ASSERT (2 * x0) + (-17 * x1) + (-13 * x2) + (8 * x3) > 1 ; +ASSERT (-4 * x0) + (-1 * x1) + (29 * x2) + (-9 * x3) > -8 ; +ASSERT (-32 * x0) + (26 * x1) + (5 * x2) + (6 * x3) <= -1 ; +ASSERT (-26 * x0) + (3 * x1) + (22 * x2) + (27 * x3) > -2 ; +ASSERT (13 * x0) + (3 * x1) + (1 * x2) + (9 * x3) < 24 ; +ASSERT (-10 * x0) + (22 * x1) + (5 * x2) + (-5 * x3) >= -21 ; +ASSERT (-20 * x0) + (-28 * x1) + (-11 * x2) + (6 * x3) >= -17 ; +ASSERT (14 * x0) + (16 * x1) + (-15 * x2) + (17 * x3) < 27 ; +ASSERT (-23 * x0) + (-4 * x1) + (-19 * x2) + (-23 * x3) < 20 ; +ASSERT (-8 * x0) + (-5 * x1) + (-17 * x2) + (32 * x3) <= 20; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-017.cvc b/test/regress/regress1/arith/arith-int-017.cvc new file mode 100644 index 000000000..e9a06125a --- /dev/null +++ b/test/regress/regress1/arith/arith-int-017.cvc @@ -0,0 +1,20 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (23 * x0) + (-4 * x1) + (-26 * x2) + (-1 * x3) = 10 ; +ASSERT (15 * x0) + (31 * x1) + (31 * x2) + (31 * x3) = 13 ; +ASSERT (19 * x0) + (-15 * x1) + (25 * x2) + (30 * x3) = 23 ; +ASSERT (10 * x0) + (-17 * x1) + (15 * x2) + (13 * x3) < 22 ; +ASSERT (-7 * x0) + (22 * x1) + (8 * x2) + (24 * x3) < 14 ; +ASSERT (24 * x0) + (-12 * x1) + (0 * x2) + (-25 * x3) <= -19 ; +ASSERT (-27 * x0) + (17 * x1) + (-20 * x2) + (-25 * x3) >= 11 ; +ASSERT (3 * x0) + (-12 * x1) + (-18 * x2) + (15 * x3) > -27 ; +ASSERT (-19 * x0) + (24 * x1) + (9 * x2) + (4 * x3) <= 16 ; +ASSERT (28 * x0) + (-20 * x1) + (-21 * x2) + (4 * x3) > -13 ; +ASSERT (-21 * x0) + (-23 * x1) + (-31 * x2) + (-6 * x3) < 6 ; +ASSERT (-30 * x0) + (8 * x1) + (-22 * x2) + (8 * x3) > 14 ; +ASSERT (-1 * x0) + (17 * x1) + (-22 * x2) + (-4 * x3) >= 4 ; +ASSERT (2 * x0) + (-4 * x1) + (10 * x2) + (30 * x3) < -15 ; +ASSERT (29 * x0) + (27 * x1) + (23 * x2) + (-4 * x3) < 21 ; +ASSERT (-28 * x0) + (0 * x1) + (19 * x2) + (7 * x3) <= -18 ; +ASSERT (-20 * x0) + (-7 * x1) + (26 * x2) + (-17 * x3) < 23; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-018.cvc b/test/regress/regress1/arith/arith-int-018.cvc new file mode 100644 index 000000000..4cb97b77e --- /dev/null +++ b/test/regress/regress1/arith/arith-int-018.cvc @@ -0,0 +1,20 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-11 * x0) + (-26 * x1) + (9 * x2) + (32 * x3) = -11 ; +ASSERT (-5 * x0) + (-11 * x1) + (-10 * x2) + (-31 * x3) = -23 ; +ASSERT (-12 * x0) + (9 * x1) + (-22 * x2) + (11 * x3) = 11 ; +ASSERT (-27 * x0) + (8 * x1) + (-28 * x2) + (-7 * x3) = 23 ; +ASSERT (19 * x0) + (4 * x1) + (5 * x2) + (-10 * x3) >= 2 ; +ASSERT (-6 * x0) + (-20 * x1) + (30 * x2) + (20 * x3) >= 12 ; +ASSERT (19 * x0) + (26 * x1) + (-21 * x2) + (18 * x3) <= -21 ; +ASSERT (8 * x0) + (-29 * x1) + (7 * x2) + (20 * x3) >= 29 ; +ASSERT (-28 * x0) + (6 * x1) + (11 * x2) + (0 * x3) >= -4 ; +ASSERT (-20 * x0) + (-30 * x1) + (17 * x2) + (25 * x3) >= 4 ; +ASSERT (-15 * x0) + (9 * x1) + (9 * x2) + (26 * x3) > 11 ; +ASSERT (-30 * x0) + (-20 * x1) + (-20 * x2) + (14 * x3) <= -27 ; +ASSERT (-22 * x0) + (-11 * x1) + (-6 * x2) + (18 * x3) > -13 ; +ASSERT (-22 * x0) + (-25 * x1) + (22 * x2) + (-24 * x3) <= 1 ; +ASSERT (-24 * x0) + (22 * x1) + (-28 * x2) + (-14 * x3) >= 18 ; +ASSERT (17 * x0) + (31 * x1) + (-13 * x2) + (-23 * x3) < -5 ; +ASSERT (-12 * x0) + (-28 * x1) + (19 * x2) + (-21 * x3) < -27; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-019.cvc b/test/regress/regress1/arith/arith-int-019.cvc new file mode 100644 index 000000000..cf9ae2d70 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-019.cvc @@ -0,0 +1,20 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (25 * x0) + (6 * x1) + (-30 * x2) + (29 * x3) = -5 ; +ASSERT (14 * x0) + (16 * x1) + (24 * x2) + (-7 * x3) <= 31 ; +ASSERT (1 * x0) + (20 * x1) + (14 * x2) + (5 * x3) >= 3 ; +ASSERT (-5 * x0) + (24 * x1) + (-21 * x2) + (-13 * x3) >= -12 ; +ASSERT (9 * x0) + (-16 * x1) + (23 * x2) + (-11 * x3) > -5 ; +ASSERT (-24 * x0) + (26 * x1) + (19 * x2) + (29 * x3) > -27 ; +ASSERT (-30 * x0) + (31 * x1) + (27 * x2) + (-26 * x3) < 23 ; +ASSERT (14 * x0) + (1 * x1) + (0 * x2) + (29 * x3) > 21 ; +ASSERT (-32 * x0) + (-5 * x1) + (27 * x2) + (31 * x3) <= 23 ; +ASSERT (30 * x0) + (10 * x1) + (30 * x2) + (29 * x3) < -28 ; +ASSERT (7 * x0) + (-4 * x1) + (-25 * x2) + (0 * x3) > -28 ; +ASSERT (3 * x0) + (-19 * x1) + (11 * x2) + (-21 * x3) <= 10 ; +ASSERT (-31 * x0) + (21 * x1) + (24 * x2) + (-17 * x3) >= 21 ; +ASSERT (-20 * x0) + (19 * x1) + (6 * x2) + (5 * x3) >= -27 ; +ASSERT (-8 * x0) + (-27 * x1) + (0 * x2) + (13 * x3) >= 12 ; +ASSERT (-21 * x0) + (7 * x1) + (-26 * x2) + (19 * x3) < -10 ; +ASSERT (32 * x0) + (-26 * x1) + (-24 * x2) + (14 * x3) < 13; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-020.cvc b/test/regress/regress1/arith/arith-int-020.cvc new file mode 100644 index 000000000..07a827465 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-020.cvc @@ -0,0 +1,20 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-32 * x0) + (31 * x1) + (-32 * x2) + (-21 * x3) = 5 ; +ASSERT (32 * x0) + (5 * x1) + (23 * x2) + (-16 * x3) = 8 ; +ASSERT (-17 * x0) + (-17 * x1) + (-22 * x2) + (30 * x3) = -5 ; +ASSERT (30 * x0) + (18 * x1) + (26 * x2) + (6 * x3) = -8 ; +ASSERT (17 * x0) + (-4 * x1) + (-16 * x2) + (-22 * x3) = 11; +ASSERT (0 * x0) + (-26 * x1) + (-15 * x2) + (12 * x3) > 7 ; +ASSERT (-30 * x0) + (4 * x1) + (-1 * x2) + (27 * x3) > 11 ; +ASSERT (23 * x0) + (12 * x1) + (11 * x2) + (-2 * x3) <= -10 ; +ASSERT (-26 * x0) + (-8 * x1) + (7 * x2) + (-18 * x3) > 1 ; +ASSERT (3 * x0) + (0 * x1) + (5 * x2) + (24 * x3) > 2 ; +ASSERT (-13 * x0) + (15 * x1) + (2 * x2) + (2 * x3) <= 17 ; +ASSERT (-24 * x0) + (21 * x1) + (-21 * x2) + (-13 * x3) >= -30 ; +ASSERT (7 * x0) + (-11 * x1) + (2 * x2) + (21 * x3) >= -24 ; +ASSERT (-15 * x0) + (-1 * x1) + (6 * x2) + (-10 * x3) <= -25 ; +ASSERT (-21 * x0) + (8 * x1) + (3 * x2) + (-5 * x3) <= 22 ; +ASSERT (-18 * x0) + (-16 * x1) + (21 * x2) + (20 * x3) >= 9 ; +ASSERT (-17 * x0) + (-10 * x1) + (-20 * x2) + (16 * x3) >= 3 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-022.cvc b/test/regress/regress1/arith/arith-int-022.cvc new file mode 100644 index 000000000..584348da4 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-022.cvc @@ -0,0 +1,4 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-24 * x0) + (25 * x1) + (-28 * x2) + (31 * x3) > 18; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-024.cvc b/test/regress/regress1/arith/arith-int-024.cvc new file mode 100644 index 000000000..f57136dd1 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-024.cvc @@ -0,0 +1,4 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (4 * x0) + (8 * x1) + (27 * x2) + (-12 * x3) = -5; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-026.cvc b/test/regress/regress1/arith/arith-int-026.cvc new file mode 100644 index 000000000..9e69aa2d1 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-026.cvc @@ -0,0 +1,21 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (22 * x0) + (25 * x1) + (1 * x2) + (-11 * x3) = 19 ; +ASSERT (-10 * x0) + (-27 * x1) + (6 * x2) + (6 * x3) = 28 ; +ASSERT (0 * x0) + (-30 * x1) + (-31 * x2) + (12 * x3) = -21 ; +ASSERT (29 * x0) + (-6 * x1) + (-12 * x2) + (22 * x3) = -13; +ASSERT (-7 * x0) + (23 * x1) + (-1 * x2) + (-14 * x3) > -6 ; +ASSERT (-27 * x0) + (-31 * x1) + (25 * x2) + (-23 * x3) <= 12 ; +ASSERT (-19 * x0) + (6 * x1) + (0 * x2) + (-28 * x3) > -1 ; +ASSERT (-12 * x0) + (19 * x1) + (2 * x2) + (-4 * x3) <= 12 ; +ASSERT (10 * x0) + (-26 * x1) + (7 * x2) + (-6 * x3) < 12 ; +ASSERT (25 * x0) + (-18 * x1) + (-30 * x2) + (-9 * x3) < -2 ; +ASSERT (-9 * x0) + (-13 * x1) + (-9 * x2) + (-28 * x3) > 18 ; +ASSERT (-12 * x0) + (-28 * x1) + (-21 * x2) + (32 * x3) > 18 ; +ASSERT (-23 * x0) + (-26 * x1) + (-21 * x2) + (-24 * x3) <= 3 ; +ASSERT (-15 * x0) + (13 * x1) + (-4 * x2) + (-1 * x3) <= 0 ; +ASSERT (11 * x0) + (-30 * x1) + (3 * x2) + (-6 * x3) >= 3 ; +ASSERT (28 * x0) + (0 * x1) + (0 * x2) + (-22 * x3) >= 9 ; +ASSERT (-18 * x0) + (15 * x1) + (-27 * x2) + (31 * x3) < 5 ; +ASSERT (10 * x0) + (30 * x1) + (-28 * x2) + (27 * x3) <= -1 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-027.cvc b/test/regress/regress1/arith/arith-int-027.cvc new file mode 100644 index 000000000..b45622fea --- /dev/null +++ b/test/regress/regress1/arith/arith-int-027.cvc @@ -0,0 +1,21 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (17 * x0) + (29 * x1) + (-11 * x2) + (24 * x3) = 13 ; +ASSERT (16 * x0) + (-20 * x1) + (-5 * x2) + (12 * x3) = 13 ; +ASSERT (-12 * x0) + (-3 * x1) + (-19 * x2) + (4 * x3) = -21 ; +ASSERT (-3 * x0) + (10 * x1) + (-6 * x2) + (-31 * x3) = 21 ; +ASSERT (10 * x0) + (-14 * x1) + (-12 * x2) + (8 * x3) = 5 ; +ASSERT (-4 * x0) + (15 * x1) + (29 * x2) + (2 * x3) = -32 ; +ASSERT (-14 * x0) + (-12 * x1) + (16 * x2) + (-14 * x3) = -8 ; +ASSERT (-31 * x0) + (14 * x1) + (30 * x2) + (-19 * x3) < -20 ; +ASSERT (-5 * x0) + (9 * x1) + (11 * x2) + (-32 * x3) < 3 ; +ASSERT (27 * x0) + (-6 * x1) + (0 * x2) + (30 * x3) <= -20 ; +ASSERT (-15 * x0) + (-13 * x1) + (-21 * x2) + (-5 * x3) > -8 ; +ASSERT (19 * x0) + (31 * x1) + (-16 * x2) + (-8 * x3) > -15 ; +ASSERT (9 * x0) + (-9 * x1) + (-4 * x2) + (-16 * x3) < 21 ; +ASSERT (24 * x0) + (4 * x1) + (28 * x2) + (-14 * x3) >= -1 ; +ASSERT (5 * x0) + (23 * x1) + (-22 * x2) + (-28 * x3) >= -21 ; +ASSERT (-31 * x0) + (14 * x1) + (14 * x2) + (-9 * x3) > -32 ; +ASSERT (25 * x0) + (-18 * x1) + (21 * x2) + (-17 * x3) < -20 ; +ASSERT (1 * x0) + (-29 * x1) + (11 * x2) + (-24 * x3) >= -20; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-028.cvc b/test/regress/regress1/arith/arith-int-028.cvc new file mode 100644 index 000000000..61fee4203 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-028.cvc @@ -0,0 +1,21 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-31 * x0) + (-5 * x1) + (-28 * x2) + (16 * x3) = 10 ; +ASSERT (3 * x0) + (-20 * x1) + (-11 * x2) + (-2 * x3) = 25 ; +ASSERT (31 * x0) + (28 * x1) + (-20 * x2) + (15 * x3) = -30; +ASSERT (15 * x0) + (-16 * x1) + (29 * x2) + (-2 * x3) >= -6 ; +ASSERT (-29 * x0) + (-17 * x1) + (-7 * x2) + (11 * x3) < 26 ; +ASSERT (-4 * x0) + (14 * x1) + (-29 * x2) + (-7 * x3) >= 28 ; +ASSERT (-29 * x0) + (-25 * x1) + (9 * x2) + (-17 * x3) <= -25 ; +ASSERT (10 * x0) + (-25 * x1) + (28 * x2) + (8 * x3) > 6 ; +ASSERT (10 * x0) + (17 * x1) + (-1 * x2) + (21 * x3) > 24 ; +ASSERT (-19 * x0) + (-29 * x1) + (-26 * x2) + (-7 * x3) <= -11 ; +ASSERT (30 * x0) + (-7 * x1) + (-8 * x2) + (6 * x3) >= -32 ; +ASSERT (-3 * x0) + (24 * x1) + (30 * x2) + (-30 * x3) >= 19 ; +ASSERT (-9 * x0) + (5 * x1) + (17 * x2) + (-24 * x3) < -22 ; +ASSERT (11 * x0) + (-16 * x1) + (-1 * x2) + (26 * x3) >= 1 ; +ASSERT (-13 * x0) + (5 * x1) + (19 * x2) + (4 * x3) >= 27 ; +ASSERT (23 * x0) + (4 * x1) + (30 * x2) + (-28 * x3) > 13 ; +ASSERT (-8 * x0) + (-24 * x1) + (0 * x2) + (22 * x3) < -6 ; +ASSERT (-1 * x0) + (1 * x1) + (-30 * x2) + (12 * x3) >= -26 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-029.cvc b/test/regress/regress1/arith/arith-int-029.cvc new file mode 100644 index 000000000..ee49bbb68 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-029.cvc @@ -0,0 +1,21 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-29 * x0) + (-17 * x1) + (11 * x2) + (1 * x3) = -15 ; +ASSERT (-13 * x0) + (1 * x1) + (-6 * x2) + (-15 * x3) = 32 ; +ASSERT (-19 * x0) + (29 * x1) + (27 * x2) + (-8 * x3) = -4 ; +ASSERT (-28 * x0) + (-15 * x1) + (-20 * x2) + (-1 * x3) = -2 ; +ASSERT (-2 * x0) + (2 * x1) + (3 * x2) + (-4 * x3) = 16 ; +ASSERT (31 * x0) + (22 * x1) + (15 * x2) + (28 * x3) = -19 ; +ASSERT (-32 * x0) + (2 * x1) + (-8 * x2) + (6 * x3) <= -21 ; +ASSERT (-10 * x0) + (23 * x1) + (-9 * x2) + (-26 * x3) < -7 ; +ASSERT (-11 * x0) + (-13 * x1) + (-17 * x2) + (-19 * x3) >= -11 ; +ASSERT (20 * x0) + (11 * x1) + (-11 * x2) + (-7 * x3) <= 14 ; +ASSERT (17 * x0) + (0 * x1) + (-27 * x2) + (-32 * x3) > -1 ; +ASSERT (17 * x0) + (-7 * x1) + (18 * x2) + (-29 * x3) > -19 ; +ASSERT (12 * x0) + (-14 * x1) + (27 * x2) + (5 * x3) <= 23 ; +ASSERT (-2 * x0) + (-6 * x1) + (-6 * x2) + (19 * x3) < -5 ; +ASSERT (-3 * x0) + (-10 * x1) + (-30 * x2) + (18 * x3) >= -27 ; +ASSERT (-18 * x0) + (-25 * x1) + (3 * x2) + (2 * x3) < -25 ; +ASSERT (-19 * x0) + (16 * x1) + (-11 * x2) + (-26 * x3) >= -24 ; +ASSERT (-2 * x0) + (21 * x1) + (25 * x2) + (28 * x3) > 10; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-030.cvc b/test/regress/regress1/arith/arith-int-030.cvc new file mode 100644 index 000000000..70b6a3785 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-030.cvc @@ -0,0 +1,21 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-13 * x0) + (26 * x1) + (-11 * x2) + (17 * x3) = 17 ; +ASSERT (-15 * x0) + (2 * x1) + (-9 * x2) + (17 * x3) = -11 ; +ASSERT (8 * x0) + (-24 * x1) + (20 * x2) + (23 * x3) = -23 ; +ASSERT (-2 * x0) + (26 * x1) + (4 * x2) + (31 * x3) < 31 ; +ASSERT (23 * x0) + (14 * x1) + (-29 * x2) + (-11 * x3) > 14 ; +ASSERT (-19 * x0) + (-32 * x1) + (11 * x2) + (31 * x3) < -4 ; +ASSERT (3 * x0) + (13 * x1) + (-19 * x2) + (26 * x3) >= -20 ; +ASSERT (-6 * x0) + (4 * x1) + (-17 * x2) + (-31 * x3) <= 32 ; +ASSERT (-13 * x0) + (32 * x1) + (-18 * x2) + (7 * x3) < -27 ; +ASSERT (-19 * x0) + (6 * x1) + (-28 * x2) + (-15 * x3) >= 30 ; +ASSERT (30 * x0) + (-24 * x1) + (-10 * x2) + (-4 * x3) >= -9 ; +ASSERT (-4 * x0) + (4 * x1) + (-27 * x2) + (-17 * x3) < 12 ; +ASSERT (-21 * x0) + (13 * x1) + (31 * x2) + (4 * x3) >= -16 ; +ASSERT (-11 * x0) + (30 * x1) + (-20 * x2) + (21 * x3) <= 9 ; +ASSERT (-12 * x0) + (23 * x1) + (2 * x2) + (12 * x3) <= 18 ; +ASSERT (30 * x0) + (8 * x1) + (4 * x2) + (-5 * x3) <= -24 ; +ASSERT (12 * x0) + (22 * x1) + (9 * x2) + (30 * x3) >= -3 ; +ASSERT (10 * x0) + (15 * x1) + (25 * x2) + (-5 * x3) <= 4; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-031.cvc b/test/regress/regress1/arith/arith-int-031.cvc new file mode 100644 index 000000000..86242f7aa --- /dev/null +++ b/test/regress/regress1/arith/arith-int-031.cvc @@ -0,0 +1,19 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-21 * x0) + (-24 * x1) + (-31 * x2) + (12 * x3) = -10 ; +ASSERT (-4 * x0) + (22 * x1) + (9 * x2) + (17 * x3) > -20 ; +ASSERT (0 * x0) + (22 * x1) + (-11 * x2) + (-22 * x3) <= 26 ; +ASSERT (17 * x0) + (-11 * x1) + (32 * x2) + (8 * x3) < 20 ; +ASSERT (-30 * x0) + (24 * x1) + (-30 * x2) + (-12 * x3) >= 19 ; +ASSERT (-27 * x0) + (5 * x1) + (31 * x2) + (-12 * x3) <= -24 ; +ASSERT (-12 * x0) + (-23 * x1) + (-27 * x2) + (29 * x3) >= 13 ; +ASSERT (23 * x0) + (-21 * x1) + (24 * x2) + (-17 * x3) >= -20 ; +ASSERT (-30 * x0) + (-27 * x1) + (-21 * x2) + (-11 * x3) < -24 ; +ASSERT (31 * x0) + (-14 * x1) + (-3 * x2) + (-9 * x3) >= 13 ; +ASSERT (8 * x0) + (-2 * x1) + (-13 * x2) + (23 * x3) < 31 ; +ASSERT (-1 * x0) + (9 * x1) + (-29 * x2) + (17 * x3) >= -7 ; +ASSERT (11 * x0) + (-8 * x1) + (-29 * x2) + (-25 * x3) >= -5 ; +ASSERT (19 * x0) + (-32 * x1) + (27 * x2) + (17 * x3) > 17 ; +ASSERT (23 * x0) + (-1 * x1) + (-9 * x2) + (-12 * x3) < -25 ; +ASSERT (16 * x0) + (-22 * x1) + (3 * x2) + (30 * x3) >= 11; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-032.cvc b/test/regress/regress1/arith/arith-int-032.cvc new file mode 100644 index 000000000..1ee4c9844 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-032.cvc @@ -0,0 +1,19 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (4 * x0) + (-29 * x1) + (-9 * x2) + (9 * x3) = 8 ; +ASSERT (-26 * x0) + (-26 * x1) + (26 * x2) + (-18 * x3) = -20 ; +ASSERT (-15 * x0) + (-4 * x1) + (-28 * x2) + (-25 * x3) = 13 ; +ASSERT (17 * x0) + (-29 * x1) + (19 * x2) + (-32 * x3) = 26 ; +ASSERT (20 * x0) + (-29 * x1) + (-32 * x2) + (28 * x3) = -12 ; +ASSERT (17 * x0) + (18 * x1) + (-18 * x2) + (28 * x3) <= 21 ; +ASSERT (-28 * x0) + (-17 * x1) + (-15 * x2) + (30 * x3) > -19 ; +ASSERT (-6 * x0) + (-25 * x1) + (-22 * x2) + (-13 * x3) < -8 ; +ASSERT (12 * x0) + (8 * x1) + (15 * x2) + (-7 * x3) >= 12 ; +ASSERT (14 * x0) + (6 * x1) + (3 * x2) + (25 * x3) > 3 ; +ASSERT (31 * x0) + (5 * x1) + (26 * x2) + (-1 * x3) < -13 ; +ASSERT (31 * x0) + (-27 * x1) + (15 * x2) + (-16 * x3) >= 11 ; +ASSERT (20 * x0) + (-20 * x1) + (25 * x2) + (18 * x3) > 18 ; +ASSERT (-2 * x0) + (-30 * x1) + (25 * x2) + (-9 * x3) < -9 ; +ASSERT (29 * x0) + (-22 * x1) + (-18 * x2) + (-25 * x3) < -2 ; +ASSERT (-12 * x0) + (9 * x1) + (17 * x2) + (-16 * x3) > 3; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-033.cvc b/test/regress/regress1/arith/arith-int-033.cvc new file mode 100644 index 000000000..599ba4e9a --- /dev/null +++ b/test/regress/regress1/arith/arith-int-033.cvc @@ -0,0 +1,19 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-14 * x0) + (16 * x1) + (-16 * x2) + (0 * x3) = -8 ; +ASSERT (3 * x0) + (-20 * x1) + (-12 * x2) + (-3 * x3) = -7 ; +ASSERT (-28 * x0) + (31 * x1) + (32 * x2) + (-11 * x3) = 0 ; +ASSERT (-20 * x0) + (-11 * x1) + (-27 * x2) + (-6 * x3) = -6 ; +ASSERT (-7 * x0) + (-7 * x1) + (17 * x2) + (-25 * x3) <= -15 ; +ASSERT (8 * x0) + (28 * x1) + (8 * x2) + (7 * x3) > -28 ; +ASSERT (25 * x0) + (7 * x1) + (-17 * x2) + (-28 * x3) > 5 ; +ASSERT (-19 * x0) + (0 * x1) + (-20 * x2) + (0 * x3) <= 20 ; +ASSERT (6 * x0) + (2 * x1) + (29 * x2) + (-19 * x3) <= -3 ; +ASSERT (-9 * x0) + (-1 * x1) + (-18 * x2) + (32 * x3) > 11 ; +ASSERT (2 * x0) + (21 * x1) + (0 * x2) + (19 * x3) >= 13 ; +ASSERT (-26 * x0) + (-6 * x1) + (-23 * x2) + (-8 * x3) < -24 ; +ASSERT (-23 * x0) + (22 * x1) + (12 * x2) + (19 * x3) < -27 ; +ASSERT (-25 * x0) + (-31 * x1) + (28 * x2) + (14 * x3) < 14 ; +ASSERT (-29 * x0) + (1 * x1) + (26 * x2) + (-27 * x3) < -14 ; +ASSERT (23 * x0) + (26 * x1) + (-5 * x2) + (6 * x3) <= -19; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-034.cvc b/test/regress/regress1/arith/arith-int-034.cvc new file mode 100644 index 000000000..ec615a785 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-034.cvc @@ -0,0 +1,19 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-20 * x0) + (-5 * x1) + (30 * x2) + (-24 * x3) = 12 ; +ASSERT (24 * x0) + (27 * x1) + (18 * x2) + (-5 * x3) = -16 ; +ASSERT (14 * x0) + (11 * x1) + (17 * x2) + (12 * x3) = -5 ; +ASSERT (-29 * x0) + (-29 * x1) + (-16 * x2) + (14 * x3) = 10 ; +ASSERT (30 * x0) + (13 * x1) + (10 * x2) + (24 * x3) = 3 ; +ASSERT (-20 * x0) + (29 * x1) + (28 * x2) + (27 * x3) < -21 ; +ASSERT (-31 * x0) + (17 * x1) + (14 * x2) + (-14 * x3) <= 14 ; +ASSERT (-23 * x0) + (19 * x1) + (28 * x2) + (-2 * x3) > -28 ; +ASSERT (-23 * x0) + (23 * x1) + (19 * x2) + (25 * x3) > 13 ; +ASSERT (-32 * x0) + (8 * x1) + (-24 * x2) + (10 * x3) >= -5 ; +ASSERT (-30 * x0) + (1 * x1) + (-22 * x2) + (12 * x3) >= -30 ; +ASSERT (8 * x0) + (28 * x1) + (17 * x2) + (-7 * x3) < -20 ; +ASSERT (-28 * x0) + (-8 * x1) + (27 * x2) + (25 * x3) >= 7 ; +ASSERT (-15 * x0) + (26 * x1) + (9 * x2) + (15 * x3) > -12 ; +ASSERT (-3 * x0) + (15 * x1) + (-6 * x2) + (-31 * x3) < -24 ; +ASSERT (-26 * x0) + (22 * x1) + (16 * x2) + (30 * x3) <= -2; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-035.cvc b/test/regress/regress1/arith/arith-int-035.cvc new file mode 100644 index 000000000..e7dee2484 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-035.cvc @@ -0,0 +1,19 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-3 * x0) + (2 * x1) + (17 * x2) + (-4 * x3) = -17 ; +ASSERT (5 * x0) + (-4 * x1) + (22 * x2) + (14 * x3) = -15 ; +ASSERT (8 * x0) + (23 * x1) + (26 * x2) + (-1 * x3) >= -6 ; +ASSERT (-7 * x0) + (4 * x1) + (9 * x2) + (-30 * x3) > -26 ; +ASSERT (-14 * x0) + (-31 * x1) + (-18 * x2) + (-5 * x3) <= 6 ; +ASSERT (15 * x0) + (26 * x1) + (3 * x2) + (-24 * x3) >= 6 ; +ASSERT (13 * x0) + (0 * x1) + (25 * x2) + (-27 * x3) <= -13 ; +ASSERT (11 * x0) + (20 * x1) + (-28 * x2) + (8 * x3) < 0 ; +ASSERT (-10 * x0) + (13 * x1) + (20 * x2) + (19 * x3) >= 29 ; +ASSERT (12 * x0) + (-9 * x1) + (-16 * x2) + (26 * x3) >= -11 ; +ASSERT (-2 * x0) + (32 * x1) + (-6 * x2) + (21 * x3) > -31 ; +ASSERT (-1 * x0) + (-22 * x1) + (-22 * x2) + (-5 * x3) > 29 ; +ASSERT (-8 * x0) + (19 * x1) + (18 * x2) + (32 * x3) >= 12 ; +ASSERT (26 * x0) + (16 * x1) + (-25 * x2) + (29 * x3) < 29 ; +ASSERT (1 * x0) + (-18 * x1) + (11 * x2) + (-10 * x3) > 10 ; +ASSERT (-21 * x0) + (5 * x1) + (-2 * x2) + (-28 * x3) <= -5; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-036.cvc b/test/regress/regress1/arith/arith-int-036.cvc new file mode 100644 index 000000000..9594f9586 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-036.cvc @@ -0,0 +1,16 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-9 * x0) + (-21 * x1) + (-25 * x2) + (-1 * x3) = -11 ; +ASSERT (31 * x0) + (-18 * x1) + (5 * x2) + (-11 * x3) = 10 ; +ASSERT (15 * x0) + (5 * x1) + (5 * x2) + (19 * x3) = -29 ; +ASSERT (-9 * x0) + (-23 * x1) + (7 * x2) + (-21 * x3) = 28 ; +ASSERT (-24 * x0) + (-22 * x1) + (30 * x2) + (-31 * x3) = -24 ; +ASSERT (-29 * x0) + (-21 * x1) + (26 * x2) + (-13 * x3) < -12 ; +ASSERT (31 * x0) + (6 * x1) + (-23 * x2) + (30 * x3) < -3 ; +ASSERT (21 * x0) + (-7 * x1) + (-4 * x2) + (-25 * x3) <= -17 ; +ASSERT (4 * x0) + (24 * x1) + (21 * x2) + (8 * x3) <= 19 ; +ASSERT (19 * x0) + (30 * x1) + (14 * x2) + (-23 * x3) > 21 ; +ASSERT (30 * x0) + (3 * x1) + (-28 * x2) + (25 * x3) <= -27 ; +ASSERT (0 * x0) + (-17 * x1) + (-9 * x2) + (-8 * x3) <= 31 ; +ASSERT (-6 * x0) + (-23 * x1) + (21 * x2) + (18 * x3) >= 31; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-037.cvc b/test/regress/regress1/arith/arith-int-037.cvc new file mode 100644 index 000000000..4d4422d3f --- /dev/null +++ b/test/regress/regress1/arith/arith-int-037.cvc @@ -0,0 +1,16 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (12 * x0) + (14 * x1) + (-22 * x2) + (-6 * x3) = 29 ; +ASSERT (-9 * x0) + (14 * x1) + (-23 * x2) + (-31 * x3) = 4 ; +ASSERT (-10 * x0) + (7 * x1) + (-23 * x2) + (18 * x3) <= -16 ; +ASSERT (-12 * x0) + (7 * x1) + (-16 * x2) + (16 * x3) > -31 ; +ASSERT (10 * x0) + (11 * x1) + (-17 * x2) + (19 * x3) <= 9 ; +ASSERT (-1 * x0) + (-8 * x1) + (-31 * x2) + (16 * x3) > 20 ; +ASSERT (-9 * x0) + (18 * x1) + (9 * x2) + (-14 * x3) <= -8 ; +ASSERT (-9 * x0) + (27 * x1) + (-22 * x2) + (-16 * x3) > 27 ; +ASSERT (-24 * x0) + (-25 * x1) + (-28 * x2) + (29 * x3) <= -9 ; +ASSERT (4 * x0) + (13 * x1) + (27 * x2) + (-5 * x3) >= -22 ; +ASSERT (-20 * x0) + (-14 * x1) + (21 * x2) + (-28 * x3) <= 17 ; +ASSERT (18 * x0) + (-32 * x1) + (-23 * x2) + (-9 * x3) <= -21 ; +ASSERT (19 * x0) + (-9 * x1) + (18 * x2) + (-9 * x3) <= -19; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-038.cvc b/test/regress/regress1/arith/arith-int-038.cvc new file mode 100644 index 000000000..476133b24 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-038.cvc @@ -0,0 +1,16 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-24 * x0) + (25 * x1) + (28 * x2) + (-31 * x3) = -1 ; +ASSERT (29 * x0) + (17 * x1) + (-2 * x2) + (-6 * x3) <= 4 ; +ASSERT (-16 * x0) + (-4 * x1) + (-2 * x2) + (-1 * x3) >= -28 ; +ASSERT (4 * x0) + (-26 * x1) + (2 * x2) + (-8 * x3) > 7 ; +ASSERT (-17 * x0) + (-6 * x1) + (11 * x2) + (-9 * x3) > -27 ; +ASSERT (-25 * x0) + (13 * x1) + (-29 * x2) + (15 * x3) > 2 ; +ASSERT (32 * x0) + (-10 * x1) + (15 * x2) + (-25 * x3) < -25 ; +ASSERT (-16 * x0) + (-26 * x1) + (16 * x2) + (3 * x3) > -26 ; +ASSERT (-14 * x0) + (13 * x1) + (4 * x2) + (-24 * x3) >= -14 ; +ASSERT (-5 * x0) + (-21 * x1) + (-7 * x2) + (10 * x3) < 0 ; +ASSERT (0 * x0) + (25 * x1) + (31 * x2) + (30 * x3) <= -25 ; +ASSERT (-1 * x0) + (2 * x1) + (26 * x2) + (4 * x3) <= 4 ; +ASSERT (14 * x0) + (23 * x1) + (18 * x2) + (-18 * x3) > 19; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-039.cvc b/test/regress/regress1/arith/arith-int-039.cvc new file mode 100644 index 000000000..9e9235ae8 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-039.cvc @@ -0,0 +1,16 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (22 * x0) + (21 * x1) + (-18 * x2) + (21 * x3) = 30 ; +ASSERT (-31 * x0) + (22 * x1) + (-20 * x2) + (18 * x3) = -32 ; +ASSERT (12 * x0) + (18 * x1) + (29 * x2) + (17 * x3) = 0 ; +ASSERT (-8 * x0) + (-10 * x1) + (-27 * x2) + (30 * x3) = 32 ; +ASSERT (-21 * x0) + (-2 * x1) + (20 * x2) + (-7 * x3) <= -27 ; +ASSERT (-7 * x0) + (-22 * x1) + (8 * x2) + (20 * x3) > -20 ; +ASSERT (-10 * x0) + (1 * x1) + (21 * x2) + (-6 * x3) > 10 ; +ASSERT (-21 * x0) + (-24 * x1) + (-15 * x2) + (4 * x3) <= 11 ; +ASSERT (-32 * x0) + (10 * x1) + (-21 * x2) + (-17 * x3) <= 5 ; +ASSERT (7 * x0) + (-19 * x1) + (28 * x2) + (27 * x3) <= 14 ; +ASSERT (-32 * x0) + (5 * x1) + (26 * x2) + (-23 * x3) < -23 ; +ASSERT (-28 * x0) + (5 * x1) + (22 * x2) + (25 * x3) < 6 ; +ASSERT (4 * x0) + (17 * x1) + (11 * x2) + (26 * x3) >= 20; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-040.cvc b/test/regress/regress1/arith/arith-int-040.cvc new file mode 100644 index 000000000..68502349f --- /dev/null +++ b/test/regress/regress1/arith/arith-int-040.cvc @@ -0,0 +1,16 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-1 * x0) + (-24 * x1) + (3 * x2) + (-8 * x3) > -5 ; +ASSERT (29 * x0) + (17 * x1) + (-26 * x2) + (20 * x3) > 11 ; +ASSERT (18 * x0) + (15 * x1) + (-27 * x2) + (8 * x3) > -11 ; +ASSERT (-14 * x0) + (4 * x1) + (27 * x2) + (-9 * x3) < -13 ; +ASSERT (24 * x0) + (11 * x1) + (17 * x2) + (-15 * x3) > 5 ; +ASSERT (-28 * x0) + (-1 * x1) + (10 * x2) + (-12 * x3) > -14 ; +ASSERT (-11 * x0) + (-4 * x1) + (7 * x2) + (-32 * x3) >= 31 ; +ASSERT (18 * x0) + (32 * x1) + (-24 * x2) + (-19 * x3) <= -6 ; +ASSERT (-15 * x0) + (23 * x1) + (-19 * x2) + (-12 * x3) < 2 ; +ASSERT (-21 * x0) + (-8 * x1) + (-30 * x2) + (31 * x3) >= -29 ; +ASSERT (5 * x0) + (-24 * x1) + (-21 * x2) + (-10 * x3) >= -8 ; +ASSERT (-31 * x0) + (-26 * x1) + (13 * x2) + (-7 * x3) <= -32 ; +ASSERT (-18 * x0) + (-11 * x1) + (9 * x2) + (6 * x3) >= 8; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-041.cvc b/test/regress/regress1/arith/arith-int-041.cvc new file mode 100644 index 000000000..a0c2dc0f9 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-041.cvc @@ -0,0 +1,9 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-31 * x0) + (8 * x1) + (16 * x2) + (5 * x3) >= 1 ; +ASSERT (-30 * x0) + (13 * x1) + (-17 * x2) + (13 * x3) < -24 ; +ASSERT (-16 * x0) + (-11 * x1) + (-32 * x2) + (-18 * x3) > -29 ; +ASSERT (32 * x0) + (-2 * x1) + (27 * x2) + (0 * x3) >= -1 ; +ASSERT (12 * x0) + (-17 * x1) + (21 * x2) + (-3 * x3) <= 1 ; +ASSERT (-26 * x0) + (29 * x1) + (-13 * x2) + (15 * x3) <= 2; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-043.cvc b/test/regress/regress1/arith/arith-int-043.cvc new file mode 100644 index 000000000..7efea85e5 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-043.cvc @@ -0,0 +1,9 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-21 * x0) + (-23 * x1) + (29 * x2) + (-4 * x3) = 25 ; +ASSERT (20 * x0) + (-19 * x1) + (3 * x2) + (-1 * x3) <= -8 ; +ASSERT (2 * x0) + (-22 * x1) + (-30 * x2) + (-9 * x3) >= 17 ; +ASSERT (21 * x0) + (5 * x1) + (-13 * x2) + (0 * x3) <= 18 ; +ASSERT (9 * x0) + (-5 * x1) + (30 * x2) + (17 * x3) > -12 ; +ASSERT (-2 * x0) + (-27 * x1) + (-5 * x2) + (-23 * x3) < 24; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-044.cvc b/test/regress/regress1/arith/arith-int-044.cvc new file mode 100644 index 000000000..f933b014b --- /dev/null +++ b/test/regress/regress1/arith/arith-int-044.cvc @@ -0,0 +1,10 @@ +% EXPECT: valid +%%%% down from 24, up from 6, up from 39 +x0, x1, x2, x3 : INT; +ASSERT (-30 * x0) + (18 * x1) + (17 * x2) + (3 * x3) = 0; +ASSERT (-25 * x0) + (-16 * x1) + (17 * x2) + (26 * x3) < 23 ; +ASSERT (-27 * x0) + (9 * x1) + (7 * x2) + (-24 * x3) < -27 ; +ASSERT (14 * x0) + (-27 * x1) + (-10 * x2) + (16 * x3) >= -23 ; +ASSERT (14 * x0) + (-27 * x1) + (-3 * x2) + (2 * x3) > -9 ; +ASSERT (-19 * x0) + (-9 * x1) + (-3 * x2) + (29 * x3) <= 5 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-045.cvc b/test/regress/regress1/arith/arith-int-045.cvc new file mode 100644 index 000000000..ca1a12ba6 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-045.cvc @@ -0,0 +1,9 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-22 * x0) + (-5 * x1) + (-5 * x2) + (25 * x3) = 22 ; +ASSERT (2 * x0) + (-25 * x1) + (4 * x2) + (-21 * x3) >= 0 ; +ASSERT (30 * x0) + (6 * x1) + (-17 * x2) + (-6 * x3) > 8 ; +ASSERT (28 * x0) + (-17 * x1) + (26 * x2) + (-1 * x3) >= 17 ; +ASSERT (2 * x0) + (-32 * x1) + (30 * x2) + (10 * x3) < -23 ; +ASSERT (22 * x0) + (-18 * x1) + (7 * x2) + (28 * x3) < -26; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-046.cvc b/test/regress/regress1/arith/arith-int-046.cvc new file mode 100644 index 000000000..d4d206c6e --- /dev/null +++ b/test/regress/regress1/arith/arith-int-046.cvc @@ -0,0 +1,6 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (2 * x0) + (-6 * x1) + (14 * x2) + (-24 * x3) > 4 ; +ASSERT (-13 * x0) + (-2 * x1) + (-9 * x2) + (-7 * x3) >= 29 ; +ASSERT (-11 * x0) + (28 * x1) + (-20 * x2) + (-2 * x3) >= 31; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-047.cvc b/test/regress/regress1/arith/arith-int-047.cvc new file mode 100644 index 000000000..0763e5dc3 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-047.cvc @@ -0,0 +1,6 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-14 * x0) + (27 * x1) + (10 * x2) + (1 * x3) = 10; +ASSERT (-29 * x0) + (-26 * x1) + (-16 * x2) + (17 * x3) >= 16 ; +ASSERT (-3 * x0) + (-2 * x1) + (26 * x2) + (30 * x3) < -27 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-048.cvc b/test/regress/regress1/arith/arith-int-048.cvc new file mode 100644 index 000000000..e7c05332d --- /dev/null +++ b/test/regress/regress1/arith/arith-int-048.cvc @@ -0,0 +1,6 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-13 * x0) + (-11 * x1) + (-14 * x2) + (21 * x3) = 6 ; +ASSERT (7 * x0) + (5 * x1) + (13 * x2) + (21 * x3) <= 27 ; +ASSERT (15 * x0) + (-11 * x1) + (-19 * x2) + (-13 * x3) < 5; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-049.cvc b/test/regress/regress1/arith/arith-int-049.cvc new file mode 100644 index 000000000..8eabc78a8 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-049.cvc @@ -0,0 +1,6 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-15 * x0) + (-20 * x1) + (-32 * x2) + (-16 * x3) = -19 ; +ASSERT (24 * x0) + (23 * x1) + (22 * x2) + (30 * x3) >= 19 ; +ASSERT (14 * x0) + (-6 * x1) + (28 * x2) + (-22 * x3) < -16; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-050.cvc b/test/regress/regress1/arith/arith-int-050.cvc new file mode 100644 index 000000000..f0ba939b7 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-050.cvc @@ -0,0 +1,6 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-20 * x0) + (-19 * x1) + (6 * x2) + (32 * x3) > 16 ; +ASSERT (-1 * x0) + (-30 * x1) + (15 * x2) + (7 * x3) < -10 ; +ASSERT (-13 * x0) + (24 * x1) + (27 * x2) + (20 * x3) < -5; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-051.cvc b/test/regress/regress1/arith/arith-int-051.cvc new file mode 100644 index 000000000..9a2497432 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-051.cvc @@ -0,0 +1,12 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-13 * x0) + (7 * x1) + (-3 * x2) + (9 * x3) = -3 ; +ASSERT (17 * x0) + (-22 * x1) + (-15 * x2) + (-21 * x3) >= 9 ; +ASSERT (-9 * x0) + (12 * x1) + (23 * x2) + (-24 * x3) >= -30 ; +ASSERT (-13 * x0) + (-3 * x1) + (-15 * x2) + (32 * x3) <= 26 ; +ASSERT (-27 * x0) + (9 * x1) + (-21 * x2) + (-5 * x3) < -9 ; +ASSERT (22 * x0) + (24 * x1) + (-10 * x2) + (-6 * x3) > -1 ; +ASSERT (20 * x0) + (-24 * x1) + (29 * x2) + (-21 * x3) <= 29 ; +ASSERT (25 * x0) + (11 * x1) + (8 * x2) + (-5 * x3) < -29 ; +ASSERT (-12 * x0) + (24 * x1) + (4 * x2) + (27 * x3) < 31; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-052.cvc b/test/regress/regress1/arith/arith-int-052.cvc new file mode 100644 index 000000000..83fdc89c8 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-052.cvc @@ -0,0 +1,12 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-25 * x0) + (-23 * x1) + (11 * x2) + (10 * x3) = 7 ; +ASSERT (32 * x0) + (-15 * x1) + (-1 * x2) + (29 * x3) > -25 ; +ASSERT (29 * x0) + (-8 * x1) + (22 * x2) + (20 * x3) < 14 ; +ASSERT (31 * x0) + (-16 * x1) + (-17 * x2) + (-21 * x3) >= 32 ; +ASSERT (-24 * x0) + (-29 * x1) + (9 * x2) + (14 * x3) <= -4 ; +ASSERT (13 * x0) + (13 * x1) + (14 * x2) + (5 * x3) <= 25 ; +ASSERT (5 * x0) + (12 * x1) + (-5 * x2) + (-9 * x3) >= -28 ; +ASSERT (27 * x0) + (19 * x1) + (6 * x2) + (25 * x3) >= -12 ; +ASSERT (24 * x0) + (-26 * x1) + (2 * x2) + (0 * x3) >= -25; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-053.cvc b/test/regress/regress1/arith/arith-int-053.cvc new file mode 100644 index 000000000..fa38fa3da --- /dev/null +++ b/test/regress/regress1/arith/arith-int-053.cvc @@ -0,0 +1,12 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-21 * x0) + (21 * x1) + (23 * x2) + (-20 * x3) = -8 ; +ASSERT (-31 * x0) + (-15 * x1) + (-23 * x2) + (29 * x3) = 17; +ASSERT (28 * x0) + (30 * x1) + (26 * x2) + (2 * x3) < 8 ; +ASSERT (17 * x0) + (-11 * x1) + (6 * x2) + (8 * x3) > 11 ; +ASSERT (20 * x0) + (-14 * x1) + (16 * x2) + (-3 * x3) < 9 ; +ASSERT (-11 * x0) + (2 * x1) + (4 * x2) + (-4 * x3) < -21 ; +ASSERT (25 * x0) + (6 * x1) + (-22 * x2) + (8 * x3) <= 7 ; +ASSERT (-8 * x0) + (9 * x1) + (-13 * x2) + (27 * x3) >= 0 ; +ASSERT (-16 * x0) + (-8 * x1) + (23 * x2) + (25 * x3) >= -13 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-054.cvc b/test/regress/regress1/arith/arith-int-054.cvc new file mode 100644 index 000000000..9b0066966 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-054.cvc @@ -0,0 +1,12 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-31 * x0) + (-29 * x1) + (6 * x2) + (8 * x3) = -10 ; +ASSERT (0 * x0) + (8 * x1) + (-20 * x2) + (12 * x3) = 16 ; +ASSERT (19 * x0) + (-30 * x1) + (8 * x2) + (-4 * x3) = -17 ; +ASSERT (-10 * x0) + (26 * x1) + (11 * x2) + (-31 * x3) = -26; +ASSERT (-22 * x0) + (15 * x1) + (14 * x2) + (3 * x3) <= -3 ; +ASSERT (-15 * x0) + (7 * x1) + (29 * x2) + (16 * x3) >= -6 ; +ASSERT (-20 * x0) + (20 * x1) + (31 * x2) + (-24 * x3) <= 14 ; +ASSERT (2 * x0) + (31 * x1) + (15 * x2) + (-1 * x3) >= -6 ; +ASSERT (-30 * x0) + (-11 * x1) + (26 * x2) + (6 * x3) >= -30 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-055.cvc b/test/regress/regress1/arith/arith-int-055.cvc new file mode 100644 index 000000000..9729fb565 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-055.cvc @@ -0,0 +1,12 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-21 * x0) + (-4 * x1) + (-28 * x2) + (-7 * x3) = -23 ; +ASSERT (-7 * x0) + (-21 * x1) + (29 * x2) + (11 * x3) = 29 ; +ASSERT (-26 * x0) + (-7 * x1) + (-25 * x2) + (-19 * x3) < -4 ; +ASSERT (4 * x0) + (14 * x1) + (-16 * x2) + (-32 * x3) >= -16 ; +ASSERT (10 * x0) + (-9 * x1) + (20 * x2) + (-27 * x3) <= 31 ; +ASSERT (29 * x0) + (16 * x1) + (25 * x2) + (-1 * x3) < -26 ; +ASSERT (-29 * x0) + (1 * x1) + (11 * x2) + (32 * x3) < 12 ; +ASSERT (-4 * x0) + (-22 * x1) + (0 * x2) + (-29 * x3) < 31 ; +ASSERT (12 * x0) + (-8 * x1) + (-17 * x2) + (-8 * x3) > 8; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-056.cvc b/test/regress/regress1/arith/arith-int-056.cvc new file mode 100644 index 000000000..e1c3ee1da --- /dev/null +++ b/test/regress/regress1/arith/arith-int-056.cvc @@ -0,0 +1,15 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-25 * x0) + (23 * x1) + (29 * x2) + (21 * x3) = -2 ; +ASSERT (1 * x0) + (10 * x1) + (-32 * x2) + (-17 * x3) = -2 ; +ASSERT (3 * x0) + (-32 * x1) + (-23 * x2) + (13 * x3) = 16 ; +ASSERT (25 * x0) + (-14 * x1) + (-17 * x2) + (16 * x3) <= 24 ; +ASSERT (1 * x0) + (-21 * x1) + (2 * x2) + (2 * x3) >= 15 ; +ASSERT (24 * x0) + (9 * x1) + (23 * x2) + (-2 * x3) >= -26 ; +%%ASSERT (-25 * x0) + (26 * x1) + (-3 * x2) + (-26 * x3) >= -20 ; +%%ASSERT (4 * x0) + (23 * x1) + (-24 * x2) + (7 * x3) <= -18 ; +%%ASSERT (-16 * x0) + (-24 * x1) + (26 * x2) + (1 * x3) > 15 ; +%%%%ASSERT (1 * x0) + (9 * x1) + (-18 * x2) + (11 * x3) > -3 ; +%%ASSERT (-9 * x0) + (20 * x1) + (15 * x2) + (4 * x3) < -17 ; +%%ASSERT (25 * x0) + (-22 * x1) + (-26 * x2) + (-21 * x3) > 17; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-057.cvc b/test/regress/regress1/arith/arith-int-057.cvc new file mode 100644 index 000000000..4e7b939b4 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-057.cvc @@ -0,0 +1,15 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-8 * x0) + (10 * x1) + (-25 * x2) + (-10 * x3) = -18 ; +ASSERT (27 * x0) + (5 * x1) + (8 * x2) + (13 * x3) = -8; +ASSERT (2 * x0) + (22 * x1) + (-13 * x2) + (16 * x3) <= 17 ; +ASSERT (18 * x0) + (18 * x1) + (15 * x2) + (-17 * x3) < -13 ; +ASSERT (-24 * x0) + (-8 * x1) + (31 * x2) + (-25 * x3) > 23 ; +ASSERT (-13 * x0) + (-22 * x1) + (11 * x2) + (28 * x3) >= -6 ; +ASSERT (20 * x0) + (-26 * x1) + (-20 * x2) + (-7 * x3) < -5 ; +ASSERT (-23 * x0) + (8 * x1) + (28 * x2) + (17 * x3) > 23 ; +ASSERT (32 * x0) + (31 * x1) + (-26 * x2) + (29 * x3) <= -1 ; +ASSERT (-2 * x0) + (-11 * x1) + (15 * x2) + (17 * x3) > -27 ; +ASSERT (-13 * x0) + (-30 * x1) + (-25 * x2) + (-18 * x3) <= 24 ; +ASSERT (23 * x0) + (-4 * x1) + (26 * x2) + (32 * x3) >= 23 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-058.cvc b/test/regress/regress1/arith/arith-int-058.cvc new file mode 100644 index 000000000..4d964f1c6 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-058.cvc @@ -0,0 +1,15 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-15 * x0) + (3 * x1) + (31 * x2) + (2 * x3) = -18 ; +ASSERT (-25 * x0) + (-10 * x1) + (15 * x2) + (29 * x3) = -18 ; +ASSERT (-17 * x0) + (31 * x1) + (-11 * x2) + (-29 * x3) = -2 ; +ASSERT (18 * x0) + (11 * x1) + (13 * x2) + (-16 * x3) >= 5 ; +ASSERT (-28 * x0) + (-30 * x1) + (13 * x2) + (-20 * x3) <= -19 ; +ASSERT (-10 * x0) + (-20 * x1) + (-13 * x2) + (-4 * x3) < 3 ; +ASSERT (-30 * x0) + (-5 * x1) + (-15 * x2) + (-1 * x3) > 19 ; +ASSERT (-8 * x0) + (28 * x1) + (17 * x2) + (23 * x3) <= 30 ; +ASSERT (-28 * x0) + (-16 * x1) + (-19 * x2) + (-23 * x3) >= 9 ; +ASSERT (-8 * x0) + (-15 * x1) + (-19 * x2) + (29 * x3) > -28 ; +ASSERT (-27 * x0) + (-12 * x1) + (-2 * x2) + (-29 * x3) >= -5 ; +ASSERT (32 * x0) + (-16 * x1) + (29 * x2) + (-12 * x3) < 26; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-059.cvc b/test/regress/regress1/arith/arith-int-059.cvc new file mode 100644 index 000000000..841d9c8e1 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-059.cvc @@ -0,0 +1,15 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (31 * x0) + (-19 * x1) + (0 * x2) + (32 * x3) = -14 ; +ASSERT (12 * x0) + (-25 * x1) + (-32 * x2) + (-18 * x3) = 18 ; +ASSERT (-6 * x0) + (-21 * x1) + (-11 * x2) + (-10 * x3) = 11 ; +ASSERT (22 * x0) + (-7 * x1) + (2 * x2) + (-16 * x3) = 16; +ASSERT (15 * x0) + (-14 * x1) + (29 * x2) + (24 * x3) >= 14 ; +ASSERT (-26 * x0) + (-6 * x1) + (-13 * x2) + (25 * x3) < -4 ; +ASSERT (-24 * x0) + (-22 * x1) + (-21 * x2) + (-6 * x3) > -21 ; +ASSERT (17 * x0) + (-21 * x1) + (25 * x2) + (-13 * x3) >= 16 ; +ASSERT (14 * x0) + (-25 * x1) + (-22 * x2) + (18 * x3) >= -30 ; +ASSERT (-27 * x0) + (8 * x1) + (-12 * x2) + (26 * x3) >= 15 ; +ASSERT (-31 * x0) + (2 * x1) + (19 * x2) + (-11 * x3) >= -27 ; +ASSERT (32 * x0) + (-29 * x1) + (9 * x2) + (-4 * x3) < 3 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-060.cvc b/test/regress/regress1/arith/arith-int-060.cvc new file mode 100644 index 000000000..227cb49b1 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-060.cvc @@ -0,0 +1,15 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (3 * x0) + (8 * x1) + (26 * x2) + (-17 * x3) = 31 ; +ASSERT (-14 * x0) + (25 * x1) + (4 * x2) + (-8 * x3) = 15 ; +ASSERT (-21 * x0) + (26 * x1) + (-10 * x2) + (-28 * x3) = 5; +ASSERT (2 * x0) + (-15 * x1) + (12 * x2) + (22 * x3) < -22 ; +ASSERT (10 * x0) + (24 * x1) + (11 * x2) + (-17 * x3) < 17 ; +ASSERT (26 * x0) + (32 * x1) + (-17 * x2) + (-3 * x3) >= 20 ; +ASSERT (11 * x0) + (26 * x1) + (-23 * x2) + (22 * x3) <= 32 ; +ASSERT (-19 * x0) + (22 * x1) + (-21 * x2) + (-28 * x3) <= -5 ; +ASSERT (-5 * x0) + (-18 * x1) + (10 * x2) + (-27 * x3) < -26 ; +ASSERT (21 * x0) + (-26 * x1) + (25 * x2) + (-13 * x3) < 15 ; +ASSERT (22 * x0) + (-2 * x1) + (3 * x2) + (-21 * x3) < 7 ; +ASSERT (20 * x0) + (-3 * x1) + (27 * x2) + (-21 * x3) < -18 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-061.cvc b/test/regress/regress1/arith/arith-int-061.cvc new file mode 100644 index 000000000..4a3cc28d0 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-061.cvc @@ -0,0 +1,23 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (16 * x0) + (20 * x1) + (-8 * x2) + (-27 * x3) = -2 ; +ASSERT (15 * x0) + (9 * x1) + (-1 * x2) + (4 * x3) = 1 ; +ASSERT (-25 * x0) + (19 * x1) + (-26 * x2) + (-20 * x3) = 22 ; +ASSERT (-11 * x0) + (28 * x1) + (-16 * x2) + (-15 * x3) = 15 ; +ASSERT (-11 * x0) + (-25 * x1) + (-16 * x2) + (25 * x3) = -3 ; +ASSERT (-15 * x0) + (-25 * x1) + (11 * x2) + (-24 * x3) = 29 ; +ASSERT (-12 * x0) + (-32 * x1) + (-28 * x2) + (-27 * x3) = -7 ; +ASSERT (16 * x0) + (5 * x1) + (10 * x2) + (-18 * x3) = 18 ; +ASSERT (-2 * x0) + (5 * x1) + (30 * x2) + (29 * x3) = -29 ; +ASSERT (-14 * x0) + (-20 * x1) + (21 * x2) + (1 * x3) = 31 ; +ASSERT (15 * x0) + (-7 * x1) + (-3 * x2) + (-24 * x3) > 3 ; +ASSERT (-16 * x0) + (-30 * x1) + (-31 * x2) + (16 * x3) > -9 ; +ASSERT (12 * x0) + (27 * x1) + (-11 * x2) + (-10 * x3) > -6 ; +ASSERT (0 * x0) + (29 * x1) + (32 * x2) + (9 * x3) <= -24 ; +ASSERT (11 * x0) + (-7 * x1) + (24 * x2) + (-30 * x3) >= 8 ; +ASSERT (1 * x0) + (25 * x1) + (29 * x2) + (15 * x3) <= -13 ; +ASSERT (-25 * x0) + (31 * x1) + (-32 * x2) + (-1 * x3) <= 9 ; +ASSERT (-22 * x0) + (-23 * x1) + (-4 * x2) + (-12 * x3) > 32 ; +ASSERT (22 * x0) + (-1 * x1) + (27 * x2) + (-22 * x3) > 20 ; +ASSERT (-20 * x0) + (-21 * x1) + (1 * x2) + (-32 * x3) >= 16; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-062.cvc b/test/regress/regress1/arith/arith-int-062.cvc new file mode 100644 index 000000000..f9a3156a2 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-062.cvc @@ -0,0 +1,23 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (11 * x0) + (22 * x1) + (19 * x2) + (-8 * x3) = 12 ; +ASSERT (23 * x0) + (-6 * x1) + (-5 * x2) + (26 * x3) = 0 ; +ASSERT (1 * x0) + (-23 * x1) + (22 * x2) + (10 * x3) = -18 ; +ASSERT (-13 * x0) + (-17 * x1) + (-8 * x2) + (-16 * x3) = 16 ; +ASSERT (24 * x0) + (-4 * x1) + (-26 * x2) + (9 * x3) = -26 ; +ASSERT (24 * x0) + (23 * x1) + (17 * x2) + (-10 * x3) >= 5 ; +ASSERT (-12 * x0) + (-12 * x1) + (-13 * x2) + (-22 * x3) <= 9 ; +ASSERT (-7 * x0) + (17 * x1) + (-24 * x2) + (-8 * x3) <= -31 ; +ASSERT (-28 * x0) + (-10 * x1) + (3 * x2) + (-23 * x3) <= -19 ; +ASSERT (12 * x0) + (-16 * x1) + (27 * x2) + (-28 * x3) > -27 ; +ASSERT (-15 * x0) + (-24 * x1) + (12 * x2) + (21 * x3) < 21 ; +ASSERT (6 * x0) + (31 * x1) + (5 * x2) + (-5 * x3) >= 10 ; +ASSERT (-7 * x0) + (-20 * x1) + (-9 * x2) + (-32 * x3) >= 7 ; +ASSERT (3 * x0) + (24 * x1) + (-18 * x2) + (-9 * x3) < -30 ; +ASSERT (-14 * x0) + (22 * x1) + (22 * x2) + (-22 * x3) < -16 ; +ASSERT (1 * x0) + (4 * x1) + (10 * x2) + (28 * x3) > -31 ; +ASSERT (-14 * x0) + (-15 * x1) + (-8 * x2) + (2 * x3) >= 3 ; +ASSERT (13 * x0) + (-27 * x1) + (-14 * x2) + (28 * x3) < 28 ; +ASSERT (26 * x0) + (-12 * x1) + (-21 * x2) + (-16 * x3) < -26 ; +ASSERT (-6 * x0) + (-19 * x1) + (-8 * x2) + (18 * x3) >= 27; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-063.cvc b/test/regress/regress1/arith/arith-int-063.cvc new file mode 100644 index 000000000..d88104688 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-063.cvc @@ -0,0 +1,23 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (20 * x0) + (-10 * x1) + (-10 * x2) + (26 * x3) = -9 ; +ASSERT (10 * x0) + (0 * x1) + (16 * x2) + (7 * x3) = 7 ; +ASSERT (6 * x0) + (-10 * x1) + (4 * x2) + (23 * x3) = 10; +ASSERT (-8 * x0) + (12 * x1) + (-19 * x2) + (-17 * x3) >= 21 ; +ASSERT (-20 * x0) + (6 * x1) + (-12 * x2) + (-31 * x3) > -31 ; +ASSERT (32 * x0) + (-6 * x1) + (-14 * x2) + (-32 * x3) >= 13 ; +ASSERT (29 * x0) + (12 * x1) + (17 * x2) + (9 * x3) > 32 ; +ASSERT (1 * x0) + (21 * x1) + (12 * x2) + (23 * x3) <= 14 ; +ASSERT (-12 * x0) + (-9 * x1) + (26 * x2) + (26 * x3) < 3 ; +ASSERT (-8 * x0) + (27 * x1) + (29 * x2) + (-10 * x3) >= 22 ; +ASSERT (-15 * x0) + (29 * x1) + (29 * x2) + (17 * x3) <= 22 ; +ASSERT (-4 * x0) + (0 * x1) + (1 * x2) + (-24 * x3) < -24 ; +ASSERT (25 * x0) + (17 * x1) + (31 * x2) + (-28 * x3) >= -12 ; +ASSERT (32 * x0) + (8 * x1) + (-3 * x2) + (19 * x3) > -19 ; +ASSERT (-27 * x0) + (-18 * x1) + (18 * x2) + (22 * x3) > 26 ; +ASSERT (29 * x0) + (29 * x1) + (4 * x2) + (-6 * x3) >= 8 ; +ASSERT (-12 * x0) + (17 * x1) + (-22 * x2) + (1 * x3) < 30 ; +ASSERT (-24 * x0) + (16 * x1) + (-26 * x2) + (-27 * x3) > 29 ; +ASSERT (9 * x0) + (15 * x1) + (-28 * x2) + (0 * x3) > -2 ; +ASSERT (-5 * x0) + (30 * x1) + (-21 * x2) + (-6 * x3) >= 12 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-064.cvc b/test/regress/regress1/arith/arith-int-064.cvc new file mode 100644 index 000000000..21ca822e1 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-064.cvc @@ -0,0 +1,23 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-8 * x0) + (-11 * x1) + (27 * x2) + (4 * x3) = 6 ; +ASSERT (32 * x0) + (27 * x1) + (31 * x2) + (-13 * x3) = 21 ; +ASSERT (-6 * x0) + (17 * x1) + (-20 * x2) + (11 * x3) < -5 ; +ASSERT (15 * x0) + (-15 * x1) + (-13 * x2) + (-21 * x3) < 27 ; +ASSERT (-24 * x0) + (-22 * x1) + (5 * x2) + (22 * x3) < 23 ; +ASSERT (27 * x0) + (23 * x1) + (-19 * x2) + (20 * x3) >= -8 ; +ASSERT (27 * x0) + (-27 * x1) + (23 * x2) + (17 * x3) < -5 ; +ASSERT (-11 * x0) + (-8 * x1) + (14 * x2) + (-10 * x3) <= 1 ; +ASSERT (12 * x0) + (7 * x1) + (-26 * x2) + (-28 * x3) >= -7 ; +ASSERT (25 * x0) + (-25 * x1) + (5 * x2) + (32 * x3) > -10 ; +ASSERT (-29 * x0) + (-24 * x1) + (26 * x2) + (-31 * x3) < -16 ; +ASSERT (10 * x0) + (29 * x1) + (9 * x2) + (23 * x3) < 13 ; +ASSERT (-26 * x0) + (6 * x1) + (-14 * x2) + (-21 * x3) > -15 ; +ASSERT (24 * x0) + (-14 * x1) + (-32 * x2) + (22 * x3) > -31 ; +ASSERT (-31 * x0) + (-16 * x1) + (-9 * x2) + (-32 * x3) > -19 ; +ASSERT (-1 * x0) + (17 * x1) + (26 * x2) + (-16 * x3) > -27 ; +ASSERT (10 * x0) + (-11 * x1) + (-20 * x2) + (-25 * x3) < -30 ; +ASSERT (-16 * x0) + (9 * x1) + (-10 * x2) + (-8 * x3) < -9 ; +ASSERT (19 * x0) + (10 * x1) + (18 * x2) + (7 * x3) < -30 ; +ASSERT (20 * x0) + (-25 * x1) + (-18 * x2) + (-2 * x3) <= -11; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-065.cvc b/test/regress/regress1/arith/arith-int-065.cvc new file mode 100644 index 000000000..b1b9e1b51 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-065.cvc @@ -0,0 +1,23 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (3 * x0) + (-21 * x1) + (-3 * x2) + (6 * x3) = -18 ; +ASSERT (-15 * x0) + (19 * x1) + (-21 * x2) + (-29 * x3) = -8 ; +ASSERT (32 * x0) + (-2 * x1) + (14 * x2) + (5 * x3) = -15 ; +ASSERT (-16 * x0) + (22 * x1) + (0 * x2) + (-26 * x3) >= 18 ; +ASSERT (11 * x0) + (-19 * x1) + (10 * x2) + (26 * x3) >= -20 ; +ASSERT (-25 * x0) + (-24 * x1) + (12 * x2) + (4 * x3) >= -14 ; +ASSERT (-20 * x0) + (-10 * x1) + (21 * x2) + (23 * x3) >= 28 ; +ASSERT (6 * x0) + (-31 * x1) + (11 * x2) + (-3 * x3) <= 4 ; +ASSERT (2 * x0) + (11 * x1) + (-13 * x2) + (-16 * x3) >= 23 ; +ASSERT (-6 * x0) + (-24 * x1) + (24 * x2) + (7 * x3) <= 14 ; +ASSERT (0 * x0) + (3 * x1) + (-14 * x2) + (-19 * x3) >= 15 ; +ASSERT (-31 * x0) + (-27 * x1) + (-32 * x2) + (-28 * x3) <= -15 ; +ASSERT (-11 * x0) + (3 * x1) + (-6 * x2) + (-5 * x3) < -31 ; +ASSERT (-2 * x0) + (-21 * x1) + (2 * x2) + (28 * x3) >= 7 ; +ASSERT (-12 * x0) + (19 * x1) + (-17 * x2) + (-14 * x3) > 11 ; +ASSERT (32 * x0) + (-29 * x1) + (-12 * x2) + (24 * x3) < -9 ; +ASSERT (-19 * x0) + (1 * x1) + (8 * x2) + (4 * x3) <= 3 ; +ASSERT (13 * x0) + (17 * x1) + (22 * x2) + (13 * x3) <= -25 ; +ASSERT (2 * x0) + (-4 * x1) + (-3 * x2) + (19 * x3) <= -12 ; +ASSERT (-16 * x0) + (-20 * x1) + (21 * x2) + (-30 * x3) <= 2; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-066.cvc b/test/regress/regress1/arith/arith-int-066.cvc new file mode 100644 index 000000000..9532b4198 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-066.cvc @@ -0,0 +1,17 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (28 * x0) + (-8 * x1) + (32 * x2) + (-3 * x3) = -18 ; +ASSERT (-4 * x0) + (5 * x1) + (-2 * x2) + (-17 * x3) > 19 ; +ASSERT (-9 * x0) + (14 * x1) + (-16 * x2) + (15 * x3) > 18 ; +ASSERT (-28 * x0) + (-25 * x1) + (-10 * x2) + (-10 * x3) < -10 ; +ASSERT (19 * x0) + (-4 * x1) + (11 * x2) + (22 * x3) <= -6 ; +ASSERT (2 * x0) + (32 * x1) + (-16 * x2) + (-29 * x3) > 6 ; +ASSERT (-7 * x0) + (9 * x1) + (-25 * x2) + (6 * x3) <= 5 ; +ASSERT (4 * x0) + (-18 * x1) + (-21 * x2) + (12 * x3) >= -32 ; +ASSERT (-27 * x0) + (11 * x1) + (-3 * x2) + (-6 * x3) < 1 ; +ASSERT (10 * x0) + (13 * x1) + (11 * x2) + (28 * x3) > -15 ; +ASSERT (-1 * x0) + (-4 * x1) + (30 * x2) + (6 * x3) > 9 ; +ASSERT (19 * x0) + (14 * x1) + (17 * x2) + (-8 * x3) <= -21 ; +ASSERT (-15 * x0) + (20 * x1) + (9 * x2) + (19 * x3) <= 4 ; +ASSERT (-9 * x0) + (-22 * x1) + (29 * x2) + (-6 * x3) <= 3; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-067.cvc b/test/regress/regress1/arith/arith-int-067.cvc new file mode 100644 index 000000000..5d7b52e69 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-067.cvc @@ -0,0 +1,17 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-25 * x0) + (-32 * x1) + (-29 * x2) + (-9 * x3) = -2 ; +ASSERT (22 * x0) + (10 * x1) + (-18 * x2) + (2 * x3) = -17 ; +ASSERT (22 * x0) + (6 * x1) + (-9 * x2) + (27 * x3) = 10 ; +ASSERT (1 * x0) + (-26 * x1) + (27 * x2) + (-19 * x3) = 29 ; +ASSERT (-13 * x0) + (18 * x1) + (5 * x2) + (22 * x3) < -10 ; +ASSERT (5 * x0) + (1 * x1) + (4 * x2) + (-7 * x3) > -12 ; +ASSERT (-30 * x0) + (-12 * x1) + (-22 * x2) + (-32 * x3) <= 1 ; +ASSERT (-15 * x0) + (19 * x1) + (22 * x2) + (-9 * x3) >= 12 ; +ASSERT (-6 * x0) + (-16 * x1) + (30 * x2) + (-13 * x3) <= -9 ; +ASSERT (-3 * x0) + (1 * x1) + (10 * x2) + (7 * x3) < -32 ; +ASSERT (5 * x0) + (-17 * x1) + (25 * x2) + (-31 * x3) >= -6 ; +ASSERT (18 * x0) + (28 * x1) + (-6 * x2) + (10 * x3) <= -31 ; +ASSERT (-11 * x0) + (-25 * x1) + (2 * x2) + (-3 * x3) > -3 ; +ASSERT (-14 * x0) + (-28 * x1) + (-2 * x2) + (20 * x3) < -25; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-068.cvc b/test/regress/regress1/arith/arith-int-068.cvc new file mode 100644 index 000000000..107a21a12 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-068.cvc @@ -0,0 +1,17 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-20 * x0) + (-8 * x1) + (5 * x2) + (-7 * x3) = -7 ; +ASSERT (-30 * x0) + (24 * x1) + (-4 * x2) + (-30 * x3) = 22 ; +ASSERT (31 * x0) + (-32 * x1) + (27 * x2) + (29 * x3) = 23 ; +ASSERT (8 * x0) + (-19 * x1) + (-7 * x2) + (0 * x3) <= -1 ; +ASSERT (-32 * x0) + (30 * x1) + (9 * x2) + (-21 * x3) <= 24 ; +ASSERT (15 * x0) + (-4 * x1) + (27 * x2) + (-26 * x3) >= 23 ; +ASSERT (7 * x0) + (26 * x1) + (-16 * x2) + (21 * x3) >= 16 ; +ASSERT (-24 * x0) + (-17 * x1) + (-9 * x2) + (27 * x3) <= 2 ; +ASSERT (29 * x0) + (-7 * x1) + (-8 * x2) + (32 * x3) <= -2 ; +ASSERT (32 * x0) + (31 * x1) + (7 * x2) + (-26 * x3) < 1 ; +ASSERT (-17 * x0) + (-13 * x1) + (-20 * x2) + (29 * x3) >= -21 ; +ASSERT (-32 * x0) + (27 * x1) + (-29 * x2) + (-11 * x3) >= -23 ; +ASSERT (29 * x0) + (-4 * x1) + (21 * x2) + (-16 * x3) < 23 ; +ASSERT (-15 * x0) + (26 * x1) + (14 * x2) + (13 * x3) <= -29; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-069.cvc b/test/regress/regress1/arith/arith-int-069.cvc new file mode 100644 index 000000000..3fab229b0 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-069.cvc @@ -0,0 +1,17 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-12 * x0) + (20 * x1) + (2 * x2) + (-24 * x3) = 16 ; +ASSERT (-32 * x0) + (27 * x1) + (1 * x2) + (-3 * x3) = -3 ; +ASSERT (13 * x0) + (27 * x1) + (-17 * x2) + (25 * x3) <= -17 ; +ASSERT (27 * x0) + (-30 * x1) + (-16 * x2) + (-3 * x3) > -19 ; +ASSERT (-18 * x0) + (-25 * x1) + (-5 * x2) + (3 * x3) < -10 ; +ASSERT (9 * x0) + (-32 * x1) + (30 * x2) + (11 * x3) >= 23 ; +ASSERT (14 * x0) + (18 * x1) + (-21 * x2) + (-19 * x3) > 9 ; +ASSERT (28 * x0) + (2 * x1) + (23 * x2) + (17 * x3) < -6 ; +ASSERT (13 * x0) + (-17 * x1) + (-1 * x2) + (29 * x3) < -22 ; +ASSERT (-19 * x0) + (22 * x1) + (6 * x2) + (12 * x3) <= -9 ; +ASSERT (24 * x0) + (-14 * x1) + (31 * x2) + (12 * x3) > -26 ; +ASSERT (-1 * x0) + (24 * x1) + (-1 * x2) + (-31 * x3) > -21 ; +ASSERT (-22 * x0) + (28 * x1) + (-27 * x2) + (0 * x3) >= 3 ; +ASSERT (-28 * x0) + (29 * x1) + (-3 * x2) + (-22 * x3) >= -23; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-070.cvc b/test/regress/regress1/arith/arith-int-070.cvc new file mode 100644 index 000000000..cd828da5f --- /dev/null +++ b/test/regress/regress1/arith/arith-int-070.cvc @@ -0,0 +1,17 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (0 * x0) + (-16 * x1) + (14 * x2) + (20 * x3) = 1 ; +ASSERT (-27 * x0) + (-5 * x1) + (-22 * x2) + (-24 * x3) = -7 ; +ASSERT (-3 * x0) + (-28 * x1) + (-15 * x2) + (7 * x3) = -9 ; +ASSERT (27 * x0) + (4 * x1) + (-31 * x2) + (-32 * x3) <= -12 ; +ASSERT (16 * x0) + (6 * x1) + (17 * x2) + (22 * x3) <= 5 ; +ASSERT (-27 * x0) + (-16 * x1) + (1 * x2) + (23 * x3) >= 9 ; +ASSERT (21 * x0) + (-28 * x1) + (-26 * x2) + (-26 * x3) <= -25 ; +ASSERT (-12 * x0) + (-32 * x1) + (-22 * x2) + (-20 * x3) > -32 ; +ASSERT (26 * x0) + (26 * x1) + (30 * x2) + (4 * x3) < 21 ; +ASSERT (-22 * x0) + (-21 * x1) + (0 * x2) + (30 * x3) < 13 ; +ASSERT (13 * x0) + (17 * x1) + (-7 * x2) + (-31 * x3) < 29 ; +ASSERT (-12 * x0) + (30 * x1) + (1 * x2) + (4 * x3) > -24 ; +ASSERT (-23 * x0) + (-2 * x1) + (29 * x2) + (11 * x3) > 26 ; +ASSERT (-18 * x0) + (-16 * x1) + (31 * x2) + (14 * x3) <= 32; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-071.cvc b/test/regress/regress1/arith/arith-int-071.cvc new file mode 100644 index 000000000..ce5336476 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-071.cvc @@ -0,0 +1,18 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (22 * x0) + (3 * x1) + (-17 * x2) + (-21 * x3) = -9 ; +ASSERT (-12 * x0) + (-9 * x1) + (-9 * x2) + (-16 * x3) = -12 ; +ASSERT (-5 * x0) + (16 * x1) + (-15 * x2) + (-13 * x3) > 27 ; +ASSERT (16 * x0) + (-4 * x1) + (17 * x2) + (-24 * x3) > -9 ; +ASSERT (3 * x0) + (13 * x1) + (-15 * x2) + (-13 * x3) <= -32 ; +ASSERT (-18 * x0) + (21 * x1) + (-7 * x2) + (2 * x3) >= 13 ; +ASSERT (5 * x0) + (11 * x1) + (-11 * x2) + (-11 * x3) <= 9 ; +ASSERT (-9 * x0) + (8 * x1) + (-25 * x2) + (-14 * x3) >= 10 ; +ASSERT (17 * x0) + (-29 * x1) + (23 * x2) + (7 * x3) <= -31 ; +ASSERT (20 * x0) + (0 * x1) + (1 * x2) + (-6 * x3) <= 23 ; +ASSERT (-25 * x0) + (0 * x1) + (-32 * x2) + (17 * x3) > -14 ; +ASSERT (6 * x0) + (-30 * x1) + (-11 * x2) + (29 * x3) < 28 ; +ASSERT (-19 * x0) + (23 * x1) + (-19 * x2) + (3 * x3) >= 7 ; +ASSERT (29 * x0) + (21 * x1) + (-28 * x2) + (-28 * x3) < 22 ; +ASSERT (28 * x0) + (25 * x1) + (2 * x2) + (-23 * x3) <= -28; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-072.cvc b/test/regress/regress1/arith/arith-int-072.cvc new file mode 100644 index 000000000..10222deae --- /dev/null +++ b/test/regress/regress1/arith/arith-int-072.cvc @@ -0,0 +1,18 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (1 * x0) + (-1 * x1) + (-16 * x2) + (6 * x3) = -11 ; +ASSERT (-17 * x0) + (17 * x1) + (-15 * x2) + (24 * x3) = -21 ; +ASSERT (-31 * x0) + (28 * x1) + (-4 * x2) + (31 * x3) = -32 ; +ASSERT (1 * x0) + (-12 * x1) + (29 * x2) + (-6 * x3) = 25 ; +ASSERT (2 * x0) + (7 * x1) + (-24 * x2) + (28 * x3) >= -12 ; +ASSERT (-23 * x0) + (-22 * x1) + (14 * x2) + (-24 * x3) >= 22 ; +ASSERT (23 * x0) + (-21 * x1) + (22 * x2) + (26 * x3) >= -4 ; +ASSERT (25 * x0) + (27 * x1) + (14 * x2) + (5 * x3) <= 9 ; +ASSERT (16 * x0) + (2 * x1) + (24 * x2) + (-11 * x3) < -32 ; +ASSERT (0 * x0) + (23 * x1) + (29 * x2) + (-15 * x3) < -14 ; +ASSERT (5 * x0) + (-12 * x1) + (-7 * x2) + (29 * x3) <= -16 ; +ASSERT (25 * x0) + (26 * x1) + (14 * x2) + (-2 * x3) <= 13 ; +ASSERT (-30 * x0) + (19 * x1) + (24 * x2) + (7 * x3) < -23 ; +ASSERT (24 * x0) + (28 * x1) + (12 * x2) + (-25 * x3) >= -22 ; +ASSERT (27 * x0) + (-13 * x1) + (-16 * x2) + (-3 * x3) < 24; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-073.cvc b/test/regress/regress1/arith/arith-int-073.cvc new file mode 100644 index 000000000..98e74be8f --- /dev/null +++ b/test/regress/regress1/arith/arith-int-073.cvc @@ -0,0 +1,18 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (8 * x0) + (-14 * x1) + (0 * x2) + (7 * x3) = 26 ; +ASSERT (-7 * x0) + (-14 * x1) + (15 * x2) + (31 * x3) = 8 ; +ASSERT (-4 * x0) + (16 * x1) + (3 * x2) + (-1 * x3) = 12 ; +ASSERT (2 * x0) + (24 * x1) + (-7 * x2) + (4 * x3) = 24 ; +ASSERT (26 * x0) + (-8 * x1) + (28 * x2) + (9 * x3) = -12 ; +ASSERT (19 * x0) + (-3 * x1) + (25 * x2) + (10 * x3) <= -19 ; +ASSERT (-13 * x0) + (-16 * x1) + (-14 * x2) + (8 * x3) <= 25 ; +ASSERT (-21 * x0) + (-2 * x1) + (-20 * x2) + (8 * x3) <= -22 ; +ASSERT (16 * x0) + (4 * x1) + (11 * x2) + (-15 * x3) >= -12 ; +ASSERT (-24 * x0) + (-8 * x1) + (2 * x2) + (-24 * x3) <= -22 ; +ASSERT (29 * x0) + (23 * x1) + (-20 * x2) + (8 * x3) > 21 ; +ASSERT (-24 * x0) + (-28 * x1) + (-23 * x2) + (-24 * x3) < -5 ; +ASSERT (-1 * x0) + (17 * x1) + (19 * x2) + (-7 * x3) > -5 ; +ASSERT (24 * x0) + (3 * x1) + (6 * x2) + (10 * x3) <= 15 ; +ASSERT (27 * x0) + (-11 * x1) + (-8 * x2) + (-22 * x3) > -30; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-074.cvc b/test/regress/regress1/arith/arith-int-074.cvc new file mode 100644 index 000000000..28cc48186 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-074.cvc @@ -0,0 +1,18 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (14 * x0) + (-6 * x1) + (-23 * x2) + (-8 * x3) = -18 ; +ASSERT (-11 * x0) + (12 * x1) + (8 * x2) + (-1 * x3) = -32 ; +ASSERT (24 * x0) + (-10 * x1) + (19 * x2) + (7 * x3) = -30 ; +ASSERT (1 * x0) + (-12 * x1) + (-13 * x2) + (-17 * x3) = -28 ; +ASSERT (-17 * x0) + (14 * x1) + (7 * x2) + (-18 * x3) = -14 ; +ASSERT (7 * x0) + (14 * x1) + (-22 * x2) + (29 * x3) = -6; +ASSERT (15 * x0) + (-6 * x1) + (3 * x2) + (-19 * x3) > 26 ; +ASSERT (-20 * x0) + (-18 * x1) + (-24 * x2) + (5 * x3) >= -1 ; +ASSERT (11 * x0) + (-26 * x1) + (-20 * x2) + (-16 * x3) > -7 ; +ASSERT (31 * x0) + (-2 * x1) + (6 * x2) + (32 * x3) > -22 ; +ASSERT (-25 * x0) + (26 * x1) + (-26 * x2) + (-21 * x3) >= -27 ; +ASSERT (-17 * x0) + (-30 * x1) + (14 * x2) + (17 * x3) <= -19 ; +ASSERT (-16 * x0) + (4 * x1) + (1 * x2) + (-24 * x3) <= -24 ; +ASSERT (-13 * x0) + (29 * x1) + (-27 * x2) + (12 * x3) < -15 ; +ASSERT (26 * x0) + (-2 * x1) + (-28 * x2) + (20 * x3) < -20 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-075.cvc b/test/regress/regress1/arith/arith-int-075.cvc new file mode 100644 index 000000000..3b5131e8b --- /dev/null +++ b/test/regress/regress1/arith/arith-int-075.cvc @@ -0,0 +1,18 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-8 * x0) + (29 * x1) + (15 * x2) + (32 * x3) = 32 ; +ASSERT (18 * x0) + (-8 * x1) + (18 * x2) + (22 * x3) = 20 ; +ASSERT (11 * x0) + (9 * x1) + (32 * x2) + (-15 * x3) > 21 ; +ASSERT (12 * x0) + (1 * x1) + (25 * x2) + (-17 * x3) > -13 ; +ASSERT (-20 * x0) + (7 * x1) + (13 * x2) + (-15 * x3) <= -3 ; +ASSERT (32 * x0) + (4 * x1) + (-30 * x2) + (13 * x3) <= -15 ; +ASSERT (-32 * x0) + (-27 * x1) + (20 * x2) + (22 * x3) <= -28 ; +ASSERT (28 * x0) + (23 * x1) + (10 * x2) + (20 * x3) < 9 ; +ASSERT (-30 * x0) + (-32 * x1) + (-28 * x2) + (-30 * x3) > 17 ; +ASSERT (-26 * x0) + (14 * x1) + (30 * x2) + (31 * x3) < 20 ; +ASSERT (21 * x0) + (23 * x1) + (-7 * x2) + (-16 * x3) > -19 ; +ASSERT (6 * x0) + (0 * x1) + (0 * x2) + (21 * x3) < -1 ; +ASSERT (13 * x0) + (29 * x1) + (17 * x2) + (-29 * x3) < -32 ; +ASSERT (22 * x0) + (-9 * x1) + (-25 * x2) + (11 * x3) > 29 ; +ASSERT (-25 * x0) + (-19 * x1) + (22 * x2) + (-27 * x3) >= 10; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-076.cvc b/test/regress/regress1/arith/arith-int-076.cvc new file mode 100644 index 000000000..2c8de7cdf --- /dev/null +++ b/test/regress/regress1/arith/arith-int-076.cvc @@ -0,0 +1,11 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-20 * x0) + (0 * x1) + (4 * x2) + (29 * x3) = -15 ; +ASSERT (3 * x0) + (19 * x1) + (21 * x2) + (-32 * x3) = 11 ; +ASSERT (-23 * x0) + (-8 * x1) + (-12 * x2) + (-14 * x3) >= -25 ; +ASSERT (13 * x0) + (30 * x1) + (-12 * x2) + (22 * x3) < -12 ; +ASSERT (-12 * x0) + (-17 * x1) + (20 * x2) + (14 * x3) > -26 ; +ASSERT (-13 * x0) + (-17 * x1) + (-25 * x2) + (27 * x3) <= -29 ; +ASSERT (-8 * x0) + (-31 * x1) + (-3 * x2) + (-22 * x3) > -22 ; +ASSERT (30 * x0) + (11 * x1) + (-32 * x2) + (32 * x3) >= 28; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-077.cvc b/test/regress/regress1/arith/arith-int-077.cvc new file mode 100644 index 000000000..d14da386e --- /dev/null +++ b/test/regress/regress1/arith/arith-int-077.cvc @@ -0,0 +1,11 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (26 * x0) + (-28 * x1) + (27 * x2) + (8 * x3) = 31 ; +ASSERT (-32 * x0) + (11 * x1) + (-5 * x2) + (14 * x3) = 2; +ASSERT (3 * x0) + (17 * x1) + (30 * x2) + (31 * x3) < 13 ; +ASSERT (-17 * x0) + (-21 * x1) + (10 * x2) + (8 * x3) > 23 ; +ASSERT (-14 * x0) + (10 * x1) + (11 * x2) + (27 * x3) > -13 ; +ASSERT (-14 * x0) + (24 * x1) + (3 * x2) + (-26 * x3) > 1 ; +ASSERT (-14 * x0) + (20 * x1) + (-2 * x2) + (-24 * x3) > -26 ; +ASSERT (20 * x0) + (-23 * x1) + (30 * x2) + (-30 * x3) < 24 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-078.cvc b/test/regress/regress1/arith/arith-int-078.cvc new file mode 100644 index 000000000..3197c6524 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-078.cvc @@ -0,0 +1,11 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (17 * x0) + (-14 * x1) + (13 * x2) + (13 * x3) = -18 ; +ASSERT (13 * x0) + (16 * x1) + (-12 * x2) + (19 * x3) = -20 ; +ASSERT (-28 * x0) + (20 * x1) + (-9 * x2) + (9 * x3) = -3 ; +ASSERT (24 * x0) + (22 * x1) + (24 * x2) + (20 * x3) = 5; +ASSERT (-1 * x0) + (-12 * x1) + (20 * x2) + (26 * x3) >= 22 ; +ASSERT (-23 * x0) + (-20 * x1) + (-8 * x2) + (1 * x3) < 2 ; +ASSERT (5 * x0) + (-27 * x1) + (-24 * x2) + (25 * x3) > -21 ; +ASSERT (1 * x0) + (-8 * x1) + (-17 * x2) + (-27 * x3) < -24 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-080.cvc b/test/regress/regress1/arith/arith-int-080.cvc new file mode 100644 index 000000000..8be0f9a73 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-080.cvc @@ -0,0 +1,11 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (5 * x0) + (-17 * x1) + (15 * x2) + (-15 * x3) = -14 ; +ASSERT (-28 * x0) + (-17 * x1) + (-29 * x2) + (-19 * x3) = 14; +ASSERT (9 * x0) + (-26 * x1) + (-16 * x2) + (-9 * x3) >= 28 ; +ASSERT (14 * x0) + (-32 * x1) + (-31 * x2) + (0 * x3) >= 30 ; +ASSERT (-31 * x0) + (-27 * x1) + (23 * x2) + (4 * x3) >= 21 ; +ASSERT (27 * x0) + (-30 * x1) + (8 * x2) + (13 * x3) < 31 ; +ASSERT (-1 * x0) + (-29 * x1) + (23 * x2) + (10 * x3) < -10 ; +ASSERT (15 * x0) + (-2 * x1) + (22 * x2) + (-28 * x3) >= 2 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-081.cvc b/test/regress/regress1/arith/arith-int-081.cvc new file mode 100644 index 000000000..546148376 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-081.cvc @@ -0,0 +1,7 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-8 * x0) + (31 * x1) + (-23 * x2) + (-8 * x3) = 8; +ASSERT (24 * x0) + (-2 * x1) + (2 * x2) + (-2 * x3) >= -17 ; +ASSERT (-6 * x0) + (17 * x1) + (27 * x2) + (26 * x3) >= -30 ; +ASSERT (-19 * x0) + (-15 * x1) + (5 * x2) + (-27 * x3) < -3 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-082.cvc b/test/regress/regress1/arith/arith-int-082.cvc new file mode 100644 index 000000000..62bd45de7 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-082.cvc @@ -0,0 +1,7 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-29 * x0) + (-3 * x1) + (27 * x2) + (13 * x3) = -10 ; +ASSERT (7 * x0) + (-17 * x1) + (11 * x2) + (-30 * x3) <= 6 ; +ASSERT (30 * x0) + (17 * x1) + (-3 * x2) + (-31 * x3) > 10 ; +ASSERT (2 * x0) + (9 * x1) + (9 * x2) + (-16 * x3) <= 11; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-083.cvc b/test/regress/regress1/arith/arith-int-083.cvc new file mode 100644 index 000000000..6b1084353 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-083.cvc @@ -0,0 +1,7 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (19 * x0) + (-31 * x1) + (31 * x2) + (28 * x3) = -13 ; +ASSERT (1 * x0) + (13 * x1) + (12 * x2) + (-15 * x3) > -8 ; +ASSERT (7 * x0) + (17 * x1) + (-20 * x2) + (13 * x3) > -26 ; +ASSERT (-17 * x0) + (14 * x1) + (-23 * x2) + (17 * x3) <= -27; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-084.cvc b/test/regress/regress1/arith/arith-int-084.cvc new file mode 100644 index 000000000..5f0e17afe --- /dev/null +++ b/test/regress/regress1/arith/arith-int-084.cvc @@ -0,0 +1,7 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-2 * x0) + (-13 * x1) + (-14 * x2) + (-26 * x3) <= 4 ; +ASSERT (-17 * x0) + (-17 * x1) + (21 * x2) + (-4 * x3) < 18 ; +ASSERT (-31 * x0) + (23 * x1) + (4 * x2) + (29 * x3) > -6 ; +ASSERT (-14 * x0) + (32 * x1) + (-8 * x2) + (-8 * x3) <= -1; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-085.cvc b/test/regress/regress1/arith/arith-int-085.cvc new file mode 100644 index 000000000..74dd714e8 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-085.cvc @@ -0,0 +1,8 @@ +% EXPECT: invalid +%% down from 3 +x0, x1, x2, x3 : INT; +ASSERT (22 * x0) + (-25 * x1) + (-20 * x2) + (8 * x3) = -6 ; +ASSERT (-9 * x0) + (30 * x1) + (-17 * x2) + (29 * x3) >= -15 ; +ASSERT (21 * x0) + (29 * x1) + (12 * x2) + (-3 * x3) <= -21 ; +ASSERT (-16 * x0) + (-26 * x1) + (11 * x2) + (-12 * x3) >= -14; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-086.cvc b/test/regress/regress1/arith/arith-int-086.cvc new file mode 100644 index 000000000..64c212b3c --- /dev/null +++ b/test/regress/regress1/arith/arith-int-086.cvc @@ -0,0 +1,13 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-16 * x0) + (28 * x1) + (2 * x2) + (7 * x3) = -25 ; +ASSERT (-20 * x0) + (-24 * x1) + (4 * x2) + (32 * x3) = -22 ; +ASSERT (19 * x0) + (28 * x1) + (-15 * x2) + (18 * x3) < -9 ; +ASSERT (-10 * x0) + (1 * x1) + (-3 * x2) + (6 * x3) <= 1 ; +ASSERT (-15 * x0) + (-32 * x1) + (28 * x2) + (6 * x3) >= -8 ; +ASSERT (-18 * x0) + (-16 * x1) + (15 * x2) + (-28 * x3) <= 1 ; +ASSERT (-20 * x0) + (-31 * x1) + (20 * x2) + (13 * x3) >= -7 ; +ASSERT (29 * x0) + (16 * x1) + (7 * x2) + (14 * x3) < 11 ; +ASSERT (-10 * x0) + (22 * x1) + (25 * x2) + (24 * x3) >= 5 ; +ASSERT (-3 * x0) + (11 * x1) + (27 * x2) + (11 * x3) <= 9; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-087.cvc b/test/regress/regress1/arith/arith-int-087.cvc new file mode 100644 index 000000000..312c08917 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-087.cvc @@ -0,0 +1,13 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-4 * x0) + (25 * x1) + (-2 * x2) + (-16 * x3) = 27 ; +ASSERT (-11 * x0) + (26 * x1) + (18 * x2) + (-18 * x3) = -15 ; +ASSERT (-19 * x0) + (-27 * x1) + (-31 * x2) + (15 * x3) = 12; +ASSERT (10 * x0) + (-10 * x1) + (25 * x2) + (-3 * x3) < -30 ; +ASSERT (5 * x0) + (-18 * x1) + (21 * x2) + (-28 * x3) <= -4 ; +ASSERT (-6 * x0) + (15 * x1) + (-10 * x2) + (0 * x3) < -20 ; +ASSERT (10 * x0) + (23 * x1) + (-20 * x2) + (12 * x3) >= -15 ; +ASSERT (-31 * x0) + (-30 * x1) + (12 * x2) + (11 * x3) > 29 ; +ASSERT (26 * x0) + (23 * x1) + (28 * x2) + (-5 * x3) > 8 ; +ASSERT (6 * x0) + (-29 * x1) + (12 * x2) + (16 * x3) < 27 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-088.cvc b/test/regress/regress1/arith/arith-int-088.cvc new file mode 100644 index 000000000..5212640be --- /dev/null +++ b/test/regress/regress1/arith/arith-int-088.cvc @@ -0,0 +1,13 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-19 * x0) + (-9 * x1) + (-27 * x2) + (9 * x3) = -1 ; +ASSERT (-26 * x0) + (11 * x1) + (23 * x2) + (-5 * x3) >= 20 ; +ASSERT (7 * x0) + (28 * x1) + (6 * x2) + (-20 * x3) <= -16 ; +ASSERT (-15 * x0) + (21 * x1) + (5 * x2) + (-2 * x3) <= 11 ; +ASSERT (-5 * x0) + (-16 * x1) + (-16 * x2) + (14 * x3) <= 12 ; +ASSERT (3 * x0) + (28 * x1) + (22 * x2) + (-6 * x3) >= -31 ; +ASSERT (15 * x0) + (-13 * x1) + (10 * x2) + (21 * x3) <= -25 ; +ASSERT (1 * x0) + (-24 * x1) + (-30 * x2) + (25 * x3) > 17 ; +ASSERT (12 * x0) + (-3 * x1) + (0 * x2) + (23 * x3) < -12 ; +ASSERT (16 * x0) + (-9 * x1) + (1 * x2) + (-15 * x3) < -6; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-089.cvc b/test/regress/regress1/arith/arith-int-089.cvc new file mode 100644 index 000000000..7ff36d29e --- /dev/null +++ b/test/regress/regress1/arith/arith-int-089.cvc @@ -0,0 +1,13 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (14 * x0) + (-14 * x1) + (-29 * x2) + (31 * x3) = -15 ; +ASSERT (-14 * x0) + (2 * x1) + (26 * x2) + (29 * x3) = 25 ; +ASSERT (19 * x0) + (-7 * x1) + (-15 * x2) + (12 * x3) = 32 ; +ASSERT (5 * x0) + (32 * x1) + (22 * x2) + (1 * x3) = -13 ; +ASSERT (-12 * x0) + (-9 * x1) + (-30 * x2) + (-13 * x3) >= 0 ; +ASSERT (-9 * x0) + (7 * x1) + (-24 * x2) + (22 * x3) >= 11 ; +ASSERT (28 * x0) + (-5 * x1) + (12 * x2) + (15 * x3) >= 31 ; +ASSERT (5 * x0) + (-6 * x1) + (5 * x2) + (-2 * x3) >= -5 ; +ASSERT (-14 * x0) + (-17 * x1) + (-29 * x2) + (-8 * x3) < -32 ; +ASSERT (20 * x0) + (-19 * x1) + (-27 * x2) + (-20 * x3) >= -2; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-090.cvc b/test/regress/regress1/arith/arith-int-090.cvc new file mode 100644 index 000000000..52b9c13f0 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-090.cvc @@ -0,0 +1,13 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-13 * x0) + (-14 * x1) + (-10 * x2) + (32 * x3) = 11 ; +ASSERT (28 * x0) + (21 * x1) + (-20 * x2) + (-32 * x3) > -31 ; +ASSERT (10 * x0) + (19 * x1) + (-10 * x2) + (-2 * x3) > -31 ; +ASSERT (-31 * x0) + (17 * x1) + (15 * x2) + (31 * x3) > -12 ; +ASSERT (-17 * x0) + (16 * x1) + (17 * x2) + (-11 * x3) >= 17 ; +ASSERT (19 * x0) + (-31 * x1) + (-16 * x2) + (-29 * x3) >= 15 ; +ASSERT (24 * x0) + (-32 * x1) + (27 * x2) + (11 * x3) < 26 ; +ASSERT (-2 * x0) + (5 * x1) + (-21 * x2) + (24 * x3) >= -17 ; +ASSERT (13 * x0) + (11 * x1) + (-28 * x2) + (-5 * x3) > 16 ; +ASSERT (-16 * x0) + (17 * x1) + (22 * x2) + (6 * x3) > 21; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-091.cvc b/test/regress/regress1/arith/arith-int-091.cvc new file mode 100644 index 000000000..29a19db39 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-091.cvc @@ -0,0 +1,22 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (26 * x0) + (32 * x1) + (-26 * x2) + (-26 * x3) = -26 ; +ASSERT (30 * x0) + (17 * x1) + (28 * x2) + (-9 * x3) = -21 ; +ASSERT (15 * x0) + (9 * x1) + (-13 * x2) + (-21 * x3) = -13 ; +ASSERT (-4 * x0) + (16 * x1) + (-5 * x2) + (8 * x3) = -25 ; +ASSERT (-11 * x0) + (26 * x1) + (1 * x2) + (23 * x3) < 6 ; +ASSERT (-31 * x0) + (-25 * x1) + (1 * x2) + (16 * x3) > -8 ; +ASSERT (9 * x0) + (-19 * x1) + (28 * x2) + (15 * x3) < -30 ; +ASSERT (32 * x0) + (18 * x1) + (2 * x2) + (31 * x3) > -7 ; +ASSERT (24 * x0) + (29 * x1) + (20 * x2) + (-16 * x3) >= 3 ; +ASSERT (-1 * x0) + (17 * x1) + (-27 * x2) + (-32 * x3) >= 20 ; +ASSERT (26 * x0) + (-23 * x1) + (6 * x2) + (30 * x3) <= 5 ; +ASSERT (13 * x0) + (6 * x1) + (-26 * x2) + (1 * x3) > -29 ; +ASSERT (26 * x0) + (2 * x1) + (8 * x2) + (-18 * x3) <= 32 ; +ASSERT (-21 * x0) + (28 * x1) + (23 * x2) + (4 * x3) <= -31 ; +ASSERT (26 * x0) + (2 * x1) + (-28 * x2) + (12 * x3) > 6 ; +ASSERT (-20 * x0) + (-22 * x1) + (-16 * x2) + (-21 * x3) <= -1 ; +ASSERT (21 * x0) + (-22 * x1) + (19 * x2) + (32 * x3) <= -10 ; +ASSERT (3 * x0) + (28 * x1) + (-11 * x2) + (0 * x3) > 0 ; +ASSERT (-13 * x0) + (-16 * x1) + (-17 * x2) + (-2 * x3) <= -17; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-092.cvc b/test/regress/regress1/arith/arith-int-092.cvc new file mode 100644 index 000000000..51c8a6bc4 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-092.cvc @@ -0,0 +1,22 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-20 * x0) + (19 * x1) + (16 * x2) + (-27 * x3) = -22 ; +ASSERT (12 * x0) + (-18 * x1) + (-25 * x2) + (-1 * x3) = -22 ; +ASSERT (17 * x0) + (11 * x1) + (24 * x2) + (16 * x3) = -3 ; +ASSERT (15 * x0) + (-10 * x1) + (-15 * x2) + (25 * x3) = -30 ; +ASSERT (7 * x0) + (26 * x1) + (-8 * x2) + (-29 * x3) >= -32 ; +ASSERT (20 * x0) + (25 * x1) + (-23 * x2) + (13 * x3) >= -30 ; +ASSERT (27 * x0) + (-32 * x1) + (-27 * x2) + (13 * x3) >= -12 ; +ASSERT (25 * x0) + (-16 * x1) + (32 * x2) + (-6 * x3) >= -30 ; +ASSERT (32 * x0) + (-18 * x1) + (-6 * x2) + (-32 * x3) <= -26 ; +ASSERT (25 * x0) + (12 * x1) + (25 * x2) + (-14 * x3) > 5 ; +ASSERT (-4 * x0) + (-20 * x1) + (12 * x2) + (-30 * x3) >= 13 ; +ASSERT (8 * x0) + (18 * x1) + (0 * x2) + (-28 * x3) <= 18 ; +ASSERT (-32 * x0) + (-25 * x1) + (23 * x2) + (5 * x3) < 29 ; +ASSERT (7 * x0) + (19 * x1) + (2 * x2) + (-31 * x3) > 7 ; +ASSERT (24 * x0) + (-17 * x1) + (-31 * x2) + (31 * x3) > 0 ; +ASSERT (13 * x0) + (20 * x1) + (-1 * x2) + (17 * x3) > 1 ; +ASSERT (17 * x0) + (26 * x1) + (6 * x2) + (29 * x3) >= -10 ; +ASSERT (-25 * x0) + (4 * x1) + (-22 * x2) + (14 * x3) < -23 ; +ASSERT (24 * x0) + (2 * x1) + (4 * x2) + (2 * x3) < 1; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-093.cvc b/test/regress/regress1/arith/arith-int-093.cvc new file mode 100644 index 000000000..7d2123d41 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-093.cvc @@ -0,0 +1,22 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (22 * x0) + (-2 * x1) + (-1 * x2) + (-24 * x3) = 8 ; +ASSERT (-6 * x0) + (9 * x1) + (-20 * x2) + (-23 * x3) = 14 ; +ASSERT (-11 * x0) + (4 * x1) + (24 * x2) + (-6 * x3) <= -23 ; +ASSERT (3 * x0) + (5 * x1) + (-5 * x2) + (17 * x3) < -17 ; +ASSERT (-10 * x0) + (-20 * x1) + (-16 * x2) + (-29 * x3) >= 6 ; +ASSERT (-28 * x0) + (1 * x1) + (-22 * x2) + (-16 * x3) >= 4 ; +ASSERT (19 * x0) + (8 * x1) + (-8 * x2) + (-2 * x3) > -23 ; +ASSERT (11 * x0) + (17 * x1) + (30 * x2) + (31 * x3) < -32 ; +ASSERT (23 * x0) + (30 * x1) + (-12 * x2) + (16 * x3) <= 4 ; +ASSERT (-23 * x0) + (-8 * x1) + (21 * x2) + (21 * x3) <= -14 ; +ASSERT (13 * x0) + (15 * x1) + (-6 * x2) + (-1 * x3) >= -8 ; +ASSERT (-21 * x0) + (18 * x1) + (27 * x2) + (-16 * x3) <= 11 ; +ASSERT (30 * x0) + (-6 * x1) + (5 * x2) + (-27 * x3) <= -7 ; +ASSERT (0 * x0) + (3 * x1) + (13 * x2) + (28 * x3) > -21 ; +ASSERT (-15 * x0) + (-20 * x1) + (10 * x2) + (-23 * x3) < 27 ; +ASSERT (24 * x0) + (6 * x1) + (-29 * x2) + (1 * x3) <= -23 ; +ASSERT (-24 * x0) + (-14 * x1) + (-15 * x2) + (8 * x3) > -19 ; +ASSERT (17 * x0) + (15 * x1) + (8 * x2) + (-31 * x3) >= -16 ; +ASSERT (-19 * x0) + (7 * x1) + (-28 * x2) + (20 * x3) < -19; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-094.cvc b/test/regress/regress1/arith/arith-int-094.cvc new file mode 100644 index 000000000..a5f1aefce --- /dev/null +++ b/test/regress/regress1/arith/arith-int-094.cvc @@ -0,0 +1,22 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (-7 * x0) + (-11 * x1) + (26 * x2) + (10 * x3) = 31 ; +ASSERT (-17 * x0) + (-20 * x1) + (24 * x2) + (-9 * x3) = -32 ; +ASSERT (5 * x0) + (14 * x1) + (7 * x2) + (-29 * x3) = 31 ; +ASSERT (17 * x0) + (8 * x1) + (23 * x2) + (-26 * x3) <= -12 ; +ASSERT (7 * x0) + (29 * x1) + (24 * x2) + (4 * x3) <= -21 ; +ASSERT (-16 * x0) + (7 * x1) + (7 * x2) + (-29 * x3) < -16 ; +ASSERT (-7 * x0) + (-11 * x1) + (-17 * x2) + (22 * x3) > -11 ; +ASSERT (-10 * x0) + (-17 * x1) + (21 * x2) + (29 * x3) > -7 ; +ASSERT (-28 * x0) + (-26 * x1) + (-24 * x2) + (-21 * x3) < -20 ; +ASSERT (-32 * x0) + (26 * x1) + (-8 * x2) + (2 * x3) >= -18 ; +ASSERT (18 * x0) + (-23 * x1) + (-26 * x2) + (-24 * x3) > -30 ; +ASSERT (-9 * x0) + (31 * x1) + (-26 * x2) + (-22 * x3) < -15 ; +ASSERT (27 * x0) + (-1 * x1) + (10 * x2) + (28 * x3) < -20 ; +ASSERT (-4 * x0) + (-22 * x1) + (-24 * x2) + (2 * x3) < -13 ; +ASSERT (-4 * x0) + (-23 * x1) + (-16 * x2) + (18 * x3) > -20 ; +ASSERT (13 * x0) + (-30 * x1) + (-3 * x2) + (-25 * x3) <= 31 ; +ASSERT (21 * x0) + (-28 * x1) + (22 * x2) + (19 * x3) > 7 ; +ASSERT (-2 * x0) + (-31 * x1) + (24 * x2) + (18 * x3) > 27 ; +ASSERT (-14 * x0) + (-5 * x1) + (-22 * x2) + (1 * x3) <= -15; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-095.cvc b/test/regress/regress1/arith/arith-int-095.cvc new file mode 100644 index 000000000..bc47d6f49 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-095.cvc @@ -0,0 +1,22 @@ +% EXPECT: valid +x0, x1, x2, x3 : INT; +ASSERT (2 * x0) + (28 * x1) + (3 * x2) + (8 * x3) > -32 ; +ASSERT (-15 * x0) + (21 * x1) + (-11 * x2) + (28 * x3) <= -19 ; +ASSERT (32 * x0) + (29 * x1) + (-1 * x2) + (-10 * x3) < -23 ; +ASSERT (6 * x0) + (-27 * x1) + (29 * x2) + (28 * x3) < 5 ; +ASSERT (-7 * x0) + (-7 * x1) + (-28 * x2) + (32 * x3) <= -32 ; +ASSERT (-10 * x0) + (20 * x1) + (-28 * x2) + (-28 * x3) >= -6 ; +ASSERT (-13 * x0) + (-9 * x1) + (4 * x2) + (-32 * x3) > -1 ; +ASSERT (-21 * x0) + (4 * x1) + (0 * x2) + (-13 * x3) >= -1 ; +ASSERT (18 * x0) + (-21 * x1) + (-16 * x2) + (24 * x3) <= -12 ; +ASSERT (18 * x0) + (-10 * x1) + (-10 * x2) + (-3 * x3) <= -10 ; +ASSERT (-32 * x0) + (9 * x1) + (-24 * x2) + (-19 * x3) < -4 ; +ASSERT (12 * x0) + (20 * x1) + (31 * x2) + (-25 * x3) <= 23 ; +ASSERT (-22 * x0) + (15 * x1) + (-12 * x2) + (-6 * x3) < 18 ; +ASSERT (-25 * x0) + (-8 * x1) + (32 * x2) + (26 * x3) > -20 ; +ASSERT (-30 * x0) + (27 * x1) + (0 * x2) + (27 * x3) >= 7 ; +ASSERT (-8 * x0) + (-2 * x1) + (-6 * x2) + (-21 * x3) <= 21 ; +ASSERT (8 * x0) + (-31 * x1) + (-4 * x2) + (1 * x3) > -11 ; +ASSERT (22 * x0) + (-25 * x1) + (-26 * x2) + (10 * x3) < -32 ; +ASSERT (-12 * x0) + (-13 * x1) + (15 * x2) + (4 * x3) < 26; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-096.cvc b/test/regress/regress1/arith/arith-int-096.cvc new file mode 100644 index 000000000..2f6cf3155 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-096.cvc @@ -0,0 +1,8 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (23 * x0) + (24 * x1) + (19 * x2) + (-3 * x3) = -16 ; +ASSERT (2 * x0) + (-13 * x1) + (5 * x2) + (-1 * x3) = 28; +ASSERT (-6 * x0) + (-5 * x1) + (-2 * x2) + (-9 * x3) > -3 ; +ASSERT (30 * x0) + (22 * x1) + (-20 * x2) + (1 * x3) > -12 ; +ASSERT (-8 * x0) + (-25 * x1) + (28 * x2) + (-25 * x3) <= -8 ; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-097.cvc b/test/regress/regress1/arith/arith-int-097.cvc new file mode 100644 index 000000000..b05061192 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-097.cvc @@ -0,0 +1,8 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (19 * x0) + (-11 * x1) + (-19 * x2) + (5 * x3) = 26 ; +ASSERT (1 * x0) + (-28 * x1) + (-2 * x2) + (15 * x3) < 9 ; +ASSERT (-8 * x0) + (-1 * x1) + (-25 * x2) + (-7 * x3) <= -31 ; +ASSERT (-7 * x0) + (11 * x1) + (-5 * x2) + (-19 * x3) > 32 ; +ASSERT (-22 * x0) + (13 * x1) + (-16 * x2) + (-12 * x3) <= 32; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-099.cvc b/test/regress/regress1/arith/arith-int-099.cvc new file mode 100644 index 000000000..0d74dcb39 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-099.cvc @@ -0,0 +1,8 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (-31 * x0) + (-20 * x1) + (-30 * x2) + (-28 * x3) = -24 ; +ASSERT (11 * x0) + (-32 * x1) + (-2 * x2) + (8 * x3) <= 16 ; +ASSERT (-10 * x0) + (16 * x1) + (31 * x2) + (19 * x3) >= -21 ; +ASSERT (-15 * x0) + (18 * x1) + (-16 * x2) + (7 * x3) <= -12 ; +ASSERT (14 * x0) + (-1 * x1) + (12 * x2) + (27 * x3) >= -12; +QUERY FALSE; diff --git a/test/regress/regress1/arith/arith-int-100.cvc b/test/regress/regress1/arith/arith-int-100.cvc new file mode 100644 index 000000000..7e07bee14 --- /dev/null +++ b/test/regress/regress1/arith/arith-int-100.cvc @@ -0,0 +1,8 @@ +% EXPECT: invalid +x0, x1, x2, x3 : INT; +ASSERT (27 * x0) + (-21 * x1) + (-6 * x2) + (-6 * x3) > -15 ; +ASSERT (-5 * x0) + (-10 * x1) + (2 * x2) + (-16 * x3) <= -7 ; +ASSERT (25 * x0) + (25 * x1) + (-15 * x2) + (-32 * x3) > -31 ; +ASSERT (17 * x0) + (-26 * x1) + (9 * x2) + (-28 * x3) >= -29 ; +ASSERT (-10 * x0) + (-18 * x1) + (15 * x2) + (0 * x3) <= 32; +QUERY FALSE; diff --git a/test/regress/regress1/arith/bug547.1.smt2 b/test/regress/regress1/arith/bug547.1.smt2 new file mode 100644 index 000000000..4b7cf9780 --- /dev/null +++ b/test/regress/regress1/arith/bug547.1.smt2 @@ -0,0 +1,8 @@ +; COMMAND-LINE: --rewrite-divk +; EXPECT: unknown +(set-logic QF_NIA) +(declare-fun x () Int) +(declare-fun y () Int) +(assert (= 1 (mod (* x y) 3))) +(check-sat) +(exit) diff --git a/test/regress/regress1/arith/bug716.0.smt2 b/test/regress/regress1/arith/bug716.0.smt2 new file mode 100644 index 000000000..2046f4911 --- /dev/null +++ b/test/regress/regress1/arith/bug716.0.smt2 @@ -0,0 +1,662 @@ +; COMMAND-LINE: --lang=smt2.5 +; SCRUBBER: sed -e 's/The fact in question: .*$/The fact in question: TERM/' -e 's/in a linear logic: .*$/in a linear logic: TERM/' +; EXPECT: (error "A non-linear fact was asserted to arithmetic in a linear logic. +; EXPECT: The fact in question: TERM +; EXPECT: ") +; EXIT: 1 +(set-logic AUFBVDTLIRA) +;; produced by cvc4_15.drv ;; +(set-info :source |VC generated by SPARK 2014|) +(set-info :smt-lib-version 2.0) +(set-info :category industrial) +(set-info :status unknown) +;;; generated by SMT-LIB2 driver +;;; SMT-LIB2 driver: bit-vectors, common part +(set-option :produce-models true) +;;; SMT-LIB2: integer arithmetic +;;; SMT-LIB2: real arithmetic +(declare-datatypes () ((tuple0 (Tuple0)))) +(declare-sort us_private 0) + +(declare-fun us_null_ext__ () us_private) + +(declare-sort us_type_of_heap 0) + +(declare-datatypes () +((us_type_of_heap__ref + (mk___type_of_heap__ref (us_type_of_heap__content us_type_of_heap))))) +(declare-sort us_image 0) + +(declare-datatypes () ((int__ref (mk_int__ref (int__content Int))))) +(declare-datatypes () ((bool__ref (mk_bool__ref (bool__content Bool))))) +(declare-datatypes () ((real__ref (mk_real__ref (real__content Real))))) +(declare-datatypes () +((us_private__ref (mk___private__ref (us_private__content us_private))))) +(define-fun int__ref___projection ((a int__ref)) Int (int__content a)) + +(define-fun bool__ref___projection ((a bool__ref)) Bool (bool__content a)) + +(define-fun real__ref___projection ((a real__ref)) Real (real__content a)) + +(define-fun us_private__ref___projection ((a us_private__ref)) us_private + (us_private__content a)) + +(declare-fun us_compatible_tags (Int Int) Bool) + +;; __compatible_tags_refl + (assert (forall ((tag Int)) (us_compatible_tags tag tag))) + +(define-fun to_int1 ((b Bool)) Int (ite (= b true) 1 0)) + +(define-fun of_int ((i Int)) Bool (ite (= i 0) false true)) + +(define-fun in_range ((x Int)) Bool (or (= x 0) (= x 1))) + +(declare-fun attr__ATTRIBUTE_IMAGE (Bool) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE (us_image) Bool) + +(declare-fun power (Real Int) Real) + +;; Power_0 + (assert (forall ((x Real)) (= (power x 0) 1.0))) + +;; Power_s + (assert + (forall ((x Real) (n Int)) + (=> (<= 0 n) (= (power x (+ n 1)) (* x (power x n)))))) + +;; Power_s_alt + (assert + (forall ((x Real) (n Int)) + (=> (< 0 n) (= (power x n) (* x (power x (- n 1))))))) + +;; Power_1 + (assert (forall ((x Real)) (= (power x 1) x))) + +;; Power_sum + (assert + (forall ((x Real) (n Int) (m Int)) + (=> (<= 0 n) + (=> (<= 0 m) (= (power x (+ n m)) (* (power x n) (power x m))))))) + +;; Power_mult + (assert + (forall ((x Real) (n Int) (m Int)) + (=> (<= 0 n) (=> (<= 0 m) (= (power x (* n m)) (power (power x n) m)))))) + +;; Power_mult2 + (assert + (forall ((x Real) (y Real) (n Int)) + (=> (<= 0 n) (= (power (* x y) n) (* (power x n) (power y n)))))) + +;; Pow_ge_one + (assert + (forall ((x Real) (n Int)) + (=> (and (<= 0 n) (<= 1.0 x)) (<= 1.0 (power x n))))) + +(declare-datatypes () +((mode (NearestTiesToEven) (ToZero) (Up) (Down) (NearestTiesToAway)))) +(declare-sort single 0) + +(declare-fun round (mode Real) Real) + +(declare-fun value (single) Real) + +(declare-fun exact (single) Real) + +(declare-fun model (single) Real) + +(define-fun round_error ((x single)) Real (ite (>= (- (value x) (exact x)) 0.0) (- + (value x) (exact x)) (- (- (value x) (exact x))))) + +(define-fun total_error ((x single)) Real (ite (>= (- (value x) (model x)) 0.0) (- + (value x) (model x)) (- (- (value x) (model x))))) + +(define-fun no_overflow ((m mode) + (x Real)) Bool (<= (ite (>= (round m x) 0.0) (round m x) (- (round m x))) 340282346638528859811704183484516925440.0)) + +;; Bounded_real_no_overflow + (assert + (forall ((m mode) (x Real)) + (=> (<= (ite (>= x 0.0) x (- x)) 340282346638528859811704183484516925440.0) + (no_overflow m x)))) + +;; Round_monotonic + (assert + (forall ((m mode) (x Real) (y Real)) + (=> (<= x y) (<= (round m x) (round m y))))) + +;; Round_idempotent + (assert + (forall ((m1 mode) (m2 mode) (x Real)) + (= (round m1 (round m2 x)) (round m2 x)))) + +;; Round_value + (assert (forall ((m mode) (x single)) (= (round m (value x)) (value x)))) + +;; Bounded_value + (assert + (forall ((x single)) + (<= (ite (>= (value x) 0.0) (value x) (- (value x))) 340282346638528859811704183484516925440.0))) + +;; Exact_rounding_for_integers + (assert + (forall ((m mode) (i Int)) + (=> (and (<= (- 16777216) i) (<= i 16777216)) + (= (round m (to_real i)) (to_real i))))) + +;; Round_down_le + (assert (forall ((x Real)) (<= (round Down x) x))) + +;; Round_up_ge + (assert (forall ((x Real)) (<= x (round Up x)))) + +;; Round_down_neg + (assert (forall ((x Real)) (= (round Down (- x)) (- (round Up x))))) + +;; Round_up_neg + (assert (forall ((x Real)) (= (round Up (- x)) (- (round Down x))))) + +(declare-fun round_logic (mode Real) single) + +;; Round_logic_def + (assert + (forall ((m mode) (x Real)) + (=> (no_overflow m x) (= (value (round_logic m x)) (round m x))))) + +(define-fun of_real_post ((m mode) (x Real) + (res single)) Bool (and (= (value res) (round m x)) + (and (= (exact res) x) (= (model res) x)))) + +(define-fun add_post ((m mode) (x single) (y single) + (res single)) Bool (and (= (value res) (round m (+ (value x) (value y)))) + (and (= (exact res) (+ (exact x) (exact y))) + (= (model res) (+ (model x) (model y)))))) + +(define-fun sub_post ((m mode) (x single) (y single) + (res single)) Bool (and (= (value res) (round m (- (value x) (value y)))) + (and (= (exact res) (- (exact x) (exact y))) + (= (model res) (- (model x) (model y)))))) + +(define-fun mul_post ((m mode) (x single) (y single) + (res single)) Bool (and (= (value res) (round m (* (value x) (value y)))) + (and (= (exact res) (* (exact x) (exact y))) + (= (model res) (* (model x) (model y)))))) + +(define-fun div_post ((m mode) (x single) (y single) + (res single)) Bool (and (= (value res) (round m (/ (value x) (value y)))) + (and (= (exact res) (/ (exact x) (exact y))) + (= (model res) (/ (model x) (model y)))))) + +(define-fun neg_post ((x single) + (res single)) Bool (and (= (value res) (- (value x))) + (and (= (exact res) (- (exact x))) + (= (model res) (- (model x)))))) + +(define-fun lt ((x single) (y single)) Bool (< (value x) (value y))) + +(define-fun gt ((x single) (y single)) Bool (< (value y) (value x))) + +(declare-sort double 0) + +(declare-fun round1 (mode Real) Real) + +(declare-fun value1 (double) Real) + +(declare-fun exact1 (double) Real) + +(declare-fun model1 (double) Real) + +(define-fun round_error1 ((x double)) Real (ite (>= (- (value1 x) (exact1 x)) 0.0) (- + (value1 x) (exact1 x)) (- (- (value1 x) (exact1 x))))) + +(define-fun total_error1 ((x double)) Real (ite (>= (- (value1 x) (model1 x)) 0.0) (- + (value1 x) (model1 x)) (- (- (value1 x) (model1 x))))) + +(define-fun no_overflow1 ((m mode) + (x Real)) Bool (<= (ite (>= (round1 m x) 0.0) (round1 m x) (- (round1 m x))) 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0)) + +;; Bounded_real_no_overflow + (assert + (forall ((m mode) (x Real)) + (=> + (<= (ite (>= x 0.0) x (- x)) 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0) + (no_overflow1 m x)))) + +;; Round_monotonic + (assert + (forall ((m mode) (x Real) (y Real)) + (=> (<= x y) (<= (round1 m x) (round1 m y))))) + +;; Round_idempotent + (assert + (forall ((m1 mode) (m2 mode) (x Real)) + (= (round1 m1 (round1 m2 x)) (round1 m2 x)))) + +;; Round_value + (assert + (forall ((m mode) (x double)) (= (round1 m (value1 x)) (value1 x)))) + +;; Bounded_value + (assert + (forall ((x double)) + (<= (ite (>= (value1 x) 0.0) (value1 x) (- (value1 x))) 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0))) + +;; Exact_rounding_for_integers + (assert + (forall ((m mode) (i Int)) + (=> (and (<= (- 9007199254740992) i) (<= i 9007199254740992)) + (= (round1 m (to_real i)) (to_real i))))) + +;; Round_down_le + (assert (forall ((x Real)) (<= (round1 Down x) x))) + +;; Round_up_ge + (assert (forall ((x Real)) (<= x (round1 Up x)))) + +;; Round_down_neg + (assert (forall ((x Real)) (= (round1 Down (- x)) (- (round1 Up x))))) + +;; Round_up_neg + (assert (forall ((x Real)) (= (round1 Up (- x)) (- (round1 Down x))))) + +(declare-fun round_logic1 (mode Real) double) + +;; Round_logic_def + (assert + (forall ((m mode) (x Real)) + (=> (no_overflow1 m x) (= (value1 (round_logic1 m x)) (round1 m x))))) + +(define-fun of_real_post1 ((m mode) (x Real) + (res double)) Bool (and (= (value1 res) (round1 m x)) + (and (= (exact1 res) x) (= (model1 res) x)))) + +(define-fun add_post1 ((m mode) (x double) (y double) + (res double)) Bool (and + (= (value1 res) (round1 m (+ (value1 x) (value1 y)))) + (and (= (exact1 res) (+ (exact1 x) (exact1 y))) + (= (model1 res) (+ (model1 x) (model1 y)))))) + +(define-fun sub_post1 ((m mode) (x double) (y double) + (res double)) Bool (and + (= (value1 res) (round1 m (- (value1 x) (value1 y)))) + (and (= (exact1 res) (- (exact1 x) (exact1 y))) + (= (model1 res) (- (model1 x) (model1 y)))))) + +(define-fun mul_post1 ((m mode) (x double) (y double) + (res double)) Bool (and + (= (value1 res) (round1 m (* (value1 x) (value1 y)))) + (and (= (exact1 res) (* (exact1 x) (exact1 y))) + (= (model1 res) (* (model1 x) (model1 y)))))) + +(define-fun div_post1 ((m mode) (x double) (y double) + (res double)) Bool (and + (= (value1 res) (round1 m (/ (value1 x) (value1 y)))) + (and (= (exact1 res) (/ (exact1 x) (exact1 y))) + (= (model1 res) (/ (model1 x) (model1 y)))))) + +(define-fun neg_post1 ((x double) + (res double)) Bool (and (= (value1 res) (- (value1 x))) + (and (= (exact1 res) (- (exact1 x))) + (= (model1 res) (- (model1 x)))))) + +(define-fun lt1 ((x double) (y double)) Bool (< (value1 x) (value1 y))) + +(define-fun gt1 ((x double) (y double)) Bool (< (value1 y) (value1 x))) + +;; round_single_bound + (assert + (forall ((x Real)) + (! (and + (<= (- (- x (* (/ 1.0 16777216.0) (ite (>= x 0.0) x (- x)))) (/ 1.0 1427247692705959881058285969449495136382746624.0)) + (round NearestTiesToEven x)) + (<= (round NearestTiesToEven x) (+ (+ x (* (/ 1.0 16777216.0) (ite (>= x 0.0) x (- x)))) (/ 1.0 1427247692705959881058285969449495136382746624.0)))) :pattern ( + (round NearestTiesToEven x)) ))) + +;; round_double_bound + (assert + (forall ((x Real)) + (! (and + (<= (- (- x (* (/ 1.0 9007199254740992.0) (ite (>= x 0.0) x (- x)))) (/ 1.0 404804506614621236704990693437834614099113299528284236713802716054860679135990693783920767402874248990374155728633623822779617474771586953734026799881477019843034848553132722728933815484186432682479535356945490137124014966849385397236206711298319112681620113024717539104666829230461005064372655017292012526615415482186989568.0)) + (round1 NearestTiesToEven x)) + (<= (round1 NearestTiesToEven x) (+ (+ x (* (/ 1.0 9007199254740992.0) (ite (>= x 0.0) x (- x)))) (/ 1.0 404804506614621236704990693437834614099113299528284236713802716054860679135990693783920767402874248990374155728633623822779617474771586953734026799881477019843034848553132722728933815484186432682479535356945490137124014966849385397236206711298319112681620113024717539104666829230461005064372655017292012526615415482186989568.0)))) :pattern ( + (round1 NearestTiesToEven x)) ))) + +;; round_double_single + (assert + (forall ((x Real)) + (! (= (round1 NearestTiesToEven (round NearestTiesToEven x)) (round + NearestTiesToEven + x)) :pattern ( + (round NearestTiesToEven x)) ))) + +(declare-fun round2 (Real) Int) + +;; Round_down + (assert + (forall ((x Real)) + (=> (< (- x (to_real (to_int x))) (/ 5.0 10.0)) (= (round2 x) (to_int x))))) + +;; Round_up + (assert + (forall ((x Real)) + (=> (< (- (to_real (- 1 (to_int (- 1.0 x)))) x) (/ 5.0 10.0)) + (= (round2 x) (- 1 (to_int (- 1.0 x))))))) + +;; Round_neg_tie + (assert + (forall ((x Real)) + (=> (and (= (- x (to_real (to_int x))) (/ 5.0 10.0)) (< x 0.0)) + (= (round2 x) (to_int x))))) + +;; Round_pos_tie + (assert + (forall ((x Real)) + (=> + (and (= (- (to_real (- 1 (to_int (- 1.0 x)))) x) (/ 5.0 10.0)) (< 0.0 x)) + (= (round2 x) (- 1 (to_int (- 1.0 x))))))) + +;; Round_int + (assert + (forall ((i Int)) + (! (= (round2 (to_real i)) i) :pattern ((round2 (to_real i))) ))) + +;; Round_near_int + (assert + (forall ((i Int)) + (forall ((x Real)) + (=> (and (< (- (/ 5.0 10.0)) x) (< x (/ 5.0 10.0))) + (= (round2 (+ (to_real i) x)) i))))) + +;; Round_monotonic + (assert + (forall ((x Real) (y Real)) (=> (<= x y) (<= (round2 x) (round2 y))))) + +;; Round_monotonic_int1 + (assert + (forall ((x Real) (i Int)) (=> (<= x (to_real i)) (<= (round2 x) i)))) + +;; Round_monotonic_int2 + (assert + (forall ((x Real) (i Int)) (=> (<= (to_real i) x) (<= i (round2 x))))) + +;; Round_bound + (assert + (forall ((x Real)) + (and (<= (- x (/ 5.0 10.0)) (to_real (round2 x))) + (<= (to_real (round2 x)) (+ x (/ 5.0 10.0)))))) + +(declare-fun remainder (Real Real) Real) + +(declare-sort float 0) + +(define-fun in_range1 ((x Real)) Bool (and + (<= (- 340282346638528859811704183484516925440.0) x) + (<= x 340282346638528859811704183484516925440.0))) + +(declare-fun to_real1 (float) Real) + +(declare-fun of_real (Real) float) + +(declare-fun user_eq (float float) Bool) + +(declare-fun next_representable (Real) Real) + +(declare-fun prev_representable (Real) Real) + +;; next_representable_def + (assert + (forall ((x Real)) + (! (< x (next_representable x)) :pattern ((next_representable x)) ))) + +;; prev_representable_def + (assert + (forall ((x Real)) + (! (< (prev_representable x) x) :pattern ((prev_representable x)) ))) + +(declare-fun attr__ATTRIBUTE_IMAGE1 (Real) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check1 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE1 (us_image) Real) + +(declare-fun dummy () float) + +;; inversion_axiom + (assert + (forall ((x float)) + (! (= (of_real (to_real1 x)) x) :pattern ((to_real1 x)) ))) + +;; representable_first + (assert + (= (round NearestTiesToEven (- 340282346638528859811704183484516925440.0)) (- 340282346638528859811704183484516925440.0))) + +;; representable_last + (assert + (= (round NearestTiesToEven 340282346638528859811704183484516925440.0) 340282346638528859811704183484516925440.0)) + +;; range_axiom + (assert (forall ((x float)) (in_range1 (to_real1 x)))) + +(declare-datatypes () ((float__ref (mk_float__ref (float__content float))))) +(define-fun float__ref___projection ((a float__ref)) float (float__content a)) + +(declare-sort weapon_kind 0) + +(define-fun in_range2 ((x Int)) Bool (and (<= 0 x) (<= x 2))) + +(define-fun bool_eq ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE2 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check2 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE2 (us_image) Int) + +(declare-fun to_rep (weapon_kind) Int) + +(declare-fun of_rep (Int) weapon_kind) + +(declare-fun user_eq1 (weapon_kind weapon_kind) Bool) + +(declare-fun dummy1 () weapon_kind) + +;; inversion_axiom + (assert + (forall ((x weapon_kind)) + (! (= (of_rep (to_rep x)) x) :pattern ((to_rep x)) ))) + +;; range_axiom + (assert + (forall ((x weapon_kind)) (! (in_range2 + (to_rep x)) :pattern ((to_rep x)) ))) + +;; coerce_axiom + (assert + (forall ((x Int)) + (! (=> (in_range2 x) (= (to_rep (of_rep x)) x)) :pattern ((to_rep + (of_rep x))) ))) + +(declare-datatypes () +((weapon_kind__ref (mk_weapon_kind__ref (weapon_kind__content weapon_kind))))) +(define-fun weapon_kind__ref___projection ((a weapon_kind__ref)) weapon_kind + (weapon_kind__content a)) + +(declare-fun dps (Int) float) + +(declare-fun damage (Int) Int) + +(declare-fun bullet (Int) Int) + +(declare-fun cooldown (Int) Int) + +;; dps__post_axiom + (assert true) + +;; dps__def_axiom + (assert + (forall ((self Int)) + (! (=> (in_range2 self) + (= (to_real1 (dps self)) (round NearestTiesToEven + (/ (round NearestTiesToEven + (to_real (damage (bullet self)))) (round + NearestTiesToEven + (to_real + (cooldown + self))))))) :pattern ( + (dps self)) ))) + +(declare-sort integer 0) + +(define-fun in_range3 ((x Int)) Bool (and (<= (- 2147483648) x) + (<= x 2147483647))) + +(define-fun bool_eq1 ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE3 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check3 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE3 (us_image) Int) + +(declare-fun to_rep1 (integer) Int) + +(declare-fun of_rep1 (Int) integer) + +(declare-fun user_eq2 (integer integer) Bool) + +(declare-fun dummy2 () integer) + +;; inversion_axiom + (assert + (forall ((x integer)) + (! (= (of_rep1 (to_rep1 x)) x) :pattern ((to_rep1 x)) ))) + +;; range_axiom + (assert + (forall ((x integer)) (! (in_range3 (to_rep1 x)) :pattern ((to_rep1 x)) ))) + +;; coerce_axiom + (assert + (forall ((x Int)) + (! (=> (in_range3 x) (= (to_rep1 (of_rep1 x)) x)) :pattern ((to_rep1 + (of_rep1 x))) ))) + +(declare-datatypes () +((integer__ref (mk_integer__ref (integer__content integer))))) +(define-fun integer__ref___projection ((a integer__ref)) integer (integer__content + a)) + +(define-fun dynamic_invariant ((temp___expr_15 Int) (temp___is_init_12 Bool) + (temp___do_constant_13 Bool) + (temp___do_toplevel_14 Bool)) Bool (=> + (or (= temp___is_init_12 true) + (<= (- 2147483648) 2147483647)) + (in_range3 temp___expr_15))) + +(declare-sort bullet_kind 0) + +(define-fun in_range4 ((x Int)) Bool (and (<= 0 x) (<= x 4))) + +(define-fun bool_eq2 ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE4 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check4 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE4 (us_image) Int) + +(declare-fun to_rep2 (bullet_kind) Int) + +(declare-fun of_rep2 (Int) bullet_kind) + +(declare-fun user_eq3 (bullet_kind bullet_kind) Bool) + +(declare-fun dummy3 () bullet_kind) + +;; inversion_axiom + (assert + (forall ((x bullet_kind)) + (! (= (of_rep2 (to_rep2 x)) x) :pattern ((to_rep2 x)) ))) + +;; range_axiom + (assert + (forall ((x bullet_kind)) (! (in_range4 + (to_rep2 x)) :pattern ((to_rep2 x)) ))) + +;; coerce_axiom + (assert + (forall ((x Int)) + (! (=> (in_range4 x) (= (to_rep2 (of_rep2 x)) x)) :pattern ((to_rep2 + (of_rep2 x))) ))) + +(declare-datatypes () +((bullet_kind__ref (mk_bullet_kind__ref (bullet_kind__content bullet_kind))))) +(define-fun bullet_kind__ref___projection ((a bullet_kind__ref)) bullet_kind + (bullet_kind__content a)) + +(define-fun dynamic_invariant1 ((temp___expr_180 Int) + (temp___is_init_177 Bool) (temp___do_constant_178 Bool) + (temp___do_toplevel_179 Bool)) Bool (=> + (or (= temp___is_init_177 true) + (<= 0 4)) (in_range4 temp___expr_180))) + +;; damage__post_axiom + (assert + (forall ((self Int)) + (! (=> (in_range4 self) (dynamic_invariant (damage self) true false true)) :pattern ( + (damage self)) ))) + +;; damage__def_axiom + (assert + (forall ((self Int)) + (! (=> (in_range4 self) + (= (damage self) (ite (= self 0) 0 + (ite (= self 1) 1 + (ite (= self 2) 8 (ite (= self 3) 10 1)))))) :pattern ( + (damage self)) ))) + +(define-fun dynamic_invariant2 ((temp___expr_186 Int) + (temp___is_init_183 Bool) (temp___do_constant_184 Bool) + (temp___do_toplevel_185 Bool)) Bool (=> + (or (= temp___is_init_183 true) + (<= 0 2)) (in_range2 temp___expr_186))) + +;; bullet__post_axiom + (assert + (forall ((self Int)) + (! (=> (in_range2 self) (dynamic_invariant1 (bullet self) true false true)) :pattern ( + (bullet self)) ))) + +;; bullet__def_axiom + (assert + (forall ((self Int)) + (! (=> (in_range2 self) + (= (bullet self) (ite (= self 0) 1 (ite (= self 1) 1 2)))) :pattern ( + (bullet self)) ))) + +;; cooldown__post_axiom + (assert + (forall ((self Int)) + (! (=> (in_range2 self) (dynamic_invariant (cooldown self) true false + true)) :pattern ((cooldown self)) ))) + +;; cooldown__def_axiom + (assert + (forall ((self Int)) + (! (=> (in_range2 self) + (= (cooldown self) (ite (= self 0) 4 (ite (= self 1) 1 8)))) :pattern ( + (cooldown self)) ))) + +(assert +;; WP_parameter_def + ;; File "weapons.ads", line 34, characters 0-0 + (not + (forall ((w Int)) + (=> (and (<= 0 w) (<= w 2)) + (or (= w 2) (<= (to_real1 (dps w)) (to_real1 (dps (+ w 1))))))))) +(check-sat) +(get-info :reason-unknown) diff --git a/test/regress/regress1/arith/bug716.1.cvc b/test/regress/regress1/arith/bug716.1.cvc new file mode 100644 index 000000000..d9330c727 --- /dev/null +++ b/test/regress/regress1/arith/bug716.1.cvc @@ -0,0 +1,6 @@ +% EXPECT: The POW(^) operator can only be used with a natural number in the exponent. Exception occurred in: +% EXPECT: 2 ^ x +% EXIT: 1 +x: INT; +ASSERT 2^x = 8; +QUERY x=3; diff --git a/test/regress/regress1/arith/div.03.smt2 b/test/regress/regress1/arith/div.03.smt2 new file mode 100644 index 000000000..8beef7a69 --- /dev/null +++ b/test/regress/regress1/arith/div.03.smt2 @@ -0,0 +1,12 @@ +; EXPECT: unsat +(set-logic QF_NIA) +(set-info :smt-lib-version 2.0) +(set-info :status unsat) +(declare-fun x () Int) +(declare-fun n () Int) + +(assert (> n 0)) +(assert (>= x n)) +(assert (< (div x n) 1)) + +(check-sat) diff --git a/test/regress/regress1/arith/div.06.smt2 b/test/regress/regress1/arith/div.06.smt2 new file mode 100644 index 000000000..6e72433ac --- /dev/null +++ b/test/regress/regress1/arith/div.06.smt2 @@ -0,0 +1,14 @@ +; EXPECT: sat +(set-logic QF_NRA) +(set-info :smt-lib-version 2.0) +(set-info :status sat) +(declare-fun x () Real) +(declare-fun y () Real) +(declare-fun n () Real) + +(assert (= (/ x n) 0)) +(assert (= (/ y n) 1)) +(assert (<= n 0)) +(assert (>= n 0)) + +(check-sat) diff --git a/test/regress/regress1/arith/div.08.smt2 b/test/regress/regress1/arith/div.08.smt2 new file mode 100644 index 000000000..0b0d73ac1 --- /dev/null +++ b/test/regress/regress1/arith/div.08.smt2 @@ -0,0 +1,11 @@ +(set-logic QF_NIA) +(set-info :smt-lib-version 2.0) +(set-info :status unsat) +(declare-fun n () Int) + + +(assert (= (div n n) (div (div n n) n))) +(assert (distinct (div (div n n) n) (div (div (div n n) n) n))) +(assert (<= n 0)) +(assert (>= n 0)) +(check-sat) diff --git a/test/regress/regress1/arith/div.09.smt2 b/test/regress/regress1/arith/div.09.smt2 new file mode 100644 index 000000000..1c4bbde2b --- /dev/null +++ b/test/regress/regress1/arith/div.09.smt2 @@ -0,0 +1,14 @@ +; SCRUBBER: sed -e 's/The fact in question: .*$/The fact in question: TERM/' +; EXPECT: (error "A non-linear fact was asserted to arithmetic in a linear logic. +; EXPECT: The fact in question: TERM +; EXPECT: ") +; EXIT: 1 +(set-logic QF_LRA) +(set-info :status unknown) +(declare-fun n () Real) + +; This example is test that LRA rejects multiplication terms + +(assert (= (/ n n) 1)) + +(check-sat) diff --git a/test/regress/regress1/arith/miplib3.cvc b/test/regress/regress1/arith/miplib3.cvc new file mode 100644 index 000000000..9e1ae5a62 --- /dev/null +++ b/test/regress/regress1/arith/miplib3.cvc @@ -0,0 +1,33 @@ +% COMMAND-LINE: --enable-miplib-trick +% EXPECT: sat + +tmp1, tmp2, tmp3, tmp4 : INT; +x, y, z : BOOLEAN; + +% x = {0, 1}, (NOT x) = 1 - x +% i*Nx + j*Ny + k = 0 +% i*x + j*Ny + k = 4 +% i*Nx + j*y + k = 6 +% i*x + j*y + k = 10 + +ASSERT NOT x AND (NOT y AND TRUE) => tmp1 = 0; +ASSERT x AND (NOT y AND TRUE) => tmp1 = 4; +ASSERT NOT x AND ( y AND TRUE) => tmp1 = 6; +ASSERT x AND ( y AND TRUE) => tmp1 = 10; + +ASSERT NOT x AND (NOT z AND TRUE) => tmp2 = 0; +ASSERT x AND (NOT z AND TRUE) => tmp2 = 2; +ASSERT NOT x AND ( z AND TRUE) => tmp2 = 9; +ASSERT x AND ( z AND TRUE) => tmp2 = 11; + +ASSERT NOT y AND (NOT z AND TRUE) => tmp3 = 0; +ASSERT y AND (NOT z AND TRUE) => tmp3 = 5; +ASSERT NOT y AND ( z AND TRUE) => tmp3 = 16; +ASSERT y AND ( z AND TRUE) => tmp3 = 21; + +ASSERT NOT x AND (NOT y AND TRUE) => tmp4 = 0; +ASSERT x AND (NOT y AND TRUE) => tmp4 = 4; +ASSERT NOT x AND ( y AND TRUE) => tmp4 = 6; +ASSERT x AND ( y AND TRUE) => tmp4 = 10; + +CHECKSAT; diff --git a/test/regress/regress1/arith/mod.02.smt2 b/test/regress/regress1/arith/mod.02.smt2 new file mode 100644 index 000000000..ee4333ea5 --- /dev/null +++ b/test/regress/regress1/arith/mod.02.smt2 @@ -0,0 +1,10 @@ +; EXPECT: unsat +(set-logic QF_NIA) +(set-info :smt-lib-version 2.0) +(set-info :status unsat) +(declare-fun n () Int) + +(assert (distinct n 0)) +(assert (> (mod n n) 0)) + +(check-sat) diff --git a/test/regress/regress1/arith/mod.03.smt2 b/test/regress/regress1/arith/mod.03.smt2 new file mode 100644 index 000000000..8a6ac51d7 --- /dev/null +++ b/test/regress/regress1/arith/mod.03.smt2 @@ -0,0 +1,11 @@ +; EXPECT: sat +(set-logic QF_NIA) +(set-info :smt-lib-version 2.0) +(set-info :status sat) +(declare-fun n () Int) +(declare-fun x () Int) + +(assert (< (mod x n) 0)) +(assert (< (div x n) 0)) + +(check-sat) diff --git a/test/regress/regress1/arith/mult.02.smt2 b/test/regress/regress1/arith/mult.02.smt2 new file mode 100644 index 000000000..57167fc76 --- /dev/null +++ b/test/regress/regress1/arith/mult.02.smt2 @@ -0,0 +1,13 @@ +; EXPECT: (error "A non-linear fact was asserted to arithmetic in a linear logic. +; EXPECT: The fact in question: (>= (* (- 1.0) (* n n)) (- 1.0)) +; EXPECT: ") +; EXIT: 1 +(set-logic QF_LRA) +(set-info :status unknown) +(declare-fun n () Real) + +; This example is test that LRA rejects multiplication terms + +(assert (= (* n n) 1)) + +(check-sat) diff --git a/test/regress/regress1/arith/problem__003.smt2 b/test/regress/regress1/arith/problem__003.smt2 new file mode 100644 index 000000000..7af727e2a --- /dev/null +++ b/test/regress/regress1/arith/problem__003.smt2 @@ -0,0 +1,21 @@ +(set-logic QF_LIA) +(set-info :source | +Alberto Griggio + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "random") +(set-info :status sat) +(declare-fun x0 () Int) +(declare-fun x1 () Int) +(declare-fun x2 () Int) +(declare-fun x3 () Int) +(declare-fun x4 () Int) +(declare-fun x5 () Int) +(declare-fun x6 () Int) +(declare-fun x7 () Int) +(declare-fun x8 () Int) +(declare-fun x9 () Int) +(assert (let ((?v_3 (* 36 x4)) (?v_0 (* 37 x7)) (?v_21 (* 3 x1)) (?v_7 (* 1 x1)) (?v_2 (* 23 x0)) (?v_4 (* 37 x1)) (?v_23 (* 15 x8)) (?v_11 (* 24 x1)) (?v_14 (* 30 x5)) (?v_17 (* 31 x6)) (?v_19 (* 28 x5)) (?v_5 (* 26 x5)) (?v_12 (* 13 x5)) (?v_20 (* 5 x6)) (?v_1 (* (- 38) x0)) (?v_18 (* (- 33) x4)) (?v_22 (* (- 38) x1)) (?v_16 (* (- 24) x6)) (?v_6 (* (- 13) x1)) (?v_9 (* (- 8) x4)) (?v_13 (* (- 11) x9)) (?v_10 (* (- 6) x0)) (?v_15 (* (- 37) x7)) (?v_8 (* (- 3) x4))) (and (<= (+ (* 25 x2) (* 12 x8) (* 12 x7) ?v_3 (* (- 5) x6) (* (- 25) x7) (* 22 x5) (* 7 x6) (* (- 19) x5) (* 22 x8)) (- 4)) (<= (+ (* 16 x1) (* 27 x2) (* 36 x6) (* 0 x8) (* 18 x4) (* (- 6) x1) (* 3 x9) (* (- 31) x9) (* 8 x0) ?v_0) (- 39)) (<= (+ (* 22 x1) (* 14 x3) (* (- 1) x2) (* (- 29) x9) (* 25 x8) (* 27 x4) (* (- 8) x3) (* (- 17) x4) ?v_1 (* 7 x7)) (- 25)) (<= (+ (* 16 x2) (* 2 x5) (* (- 34) x8) (* 3 x7) ?v_21 (* (- 17) x9) (* (- 32) x4) (* (- 7) x9) (* (- 9) x2) (* 16 x8)) (- 39)) (<= (+ ?v_7 (* (- 8) x5) (* 6 x4) ?v_18 (* (- 37) x0) (* 16 x6) (* (- 12) x0) (* 22 x3) (* (- 36) x3) (* 36 x0)) 6) (<= (+ (* 9 x3) (* (- 36) x4) (* (- 32) x8) (* (- 16) x1) ?v_0 ?v_2 (* (- 6) x5) (* (- 31) x6) (* (- 5) x8) (* (- 15) x3)) (- 15)) (<= (+ (* 1 x8) (* (- 7) x6) ?v_4 (* 20 x2) ?v_1 (* 0 x0) (* (- 37) x8) (* 13 x3) (* (- 23) x7) (* 37 x9)) (- 14)) (<= (+ (* 34 x5) (* 10 x6) (* (- 3) x5) (* (- 38) x9) ?v_22 (* 19 x6) (* (- 39) x7) ?v_16 (* 12 x1) (* (- 3) x7)) 35) (<= (+ (* 20 x4) (* (- 39) x9) (* 24 x3) ?v_23 (* (- 18) x3) ?v_11 (* (- 23) x4) ?v_14 (* 11 x2) (* (- 1) x5)) (- 13)) (<= (+ (* 30 x9) ?v_17 (* 14 x2) ?v_6 (* (- 16) x8) (* 29 x1) (* (- 3) x6) ?v_9 (* (- 10) x8) ?v_19) (- 39)) (<= (+ (* 8 x4) (* 37 x2) ?v_13 (* 23 x2) ?v_2 (* (- 4) x1) (* 10 x5) (* (- 36) x0) (* (- 15) x0) (* (- 22) x3)) (- 24)) (<= (+ (* 38 x2) (* 23 x3) (* 12 x2) ?v_10 ?v_3 (* 29 x6) (* 4 x0) ?v_5 ?v_15 (* (- 10) x9)) 16) (<= (+ (* 31 x4) (* (- 26) x0) (* (- 19) x9) (* (- 21) x4) ?v_4 ?v_8 ?v_5 ?v_12 (* (- 20) x4) (* (- 31) x2)) (- 12)) (<= (+ (* 38 x9) (* (- 28) x1) (* 29 x0) (* 5 x1) (* (- 38) x8) ?v_6 (* (- 8) x2) ?v_20 (* 22 x7) (* (- 24) x9)) 10) (<= (+ ?v_7 ?v_8 (* 35 x5) (* 16 x3) (* 6 x7) ?v_9 (* (- 2) x3) (* (- 38) x5) ?v_10 (* (- 7) x4)) (- 29)) (<= (+ (* 11 x3) (* 5 x4) (* (- 2) x4) (* 37 x6) ?v_11 (* 0 x9) (* 25 x1) (* (- 3) x9) (* (- 33) x9) (* 19 x9)) (- 37)) (<= (+ ?v_12 (* 7 x4) ?v_13 ?v_14 (* (- 31) x0) (* (- 12) x6) (* (- 35) x0) (* 36 x2) (* (- 25) x3) ?v_15) (- 33)) (<= (+ (* 10 x4) ?v_16 (* 26 x6) ?v_17 ?v_18 (* (- 32) x5) (* 32 x2) (* 34 x8) (* 19 x1) ?v_1) (- 9)) (<= (+ ?v_12 (* (- 9) x3) (* (- 37) x3) (* 34 x4) (* 0 x1) ?v_19 (* 30 x6) (* (- 18) x4) (* 21 x5) (* (- 21) x9)) (- 9)) (<= (+ ?v_20 (* (- 30) x6) ?v_21 (* 9 x8) ?v_13 (* (- 28) x5) (* (- 14) x3) ?v_22 (* 5 x8) ?v_23) 35)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/arrayinuf_error.smt2 b/test/regress/regress1/arrayinuf_error.smt2 new file mode 100644 index 000000000..1fedd95ac --- /dev/null +++ b/test/regress/regress1/arrayinuf_error.smt2 @@ -0,0 +1,8 @@ +; EXPECT: (error "Parse Error: arrayinuf_error.smt2:7.21: Symbol 'Array' not declared as a type +; EXPECT: +; EXPECT: (declare-fun a (Array Bool Bool)) +; EXPECT: ^ +; EXPECT: ") +(set-logic QF_UF) +(declare-fun a (Array Bool Bool)) +; EXIT: 1 diff --git a/test/regress/regress1/aufbv/Makefile.am b/test/regress/regress1/aufbv/Makefile.am index 4caeca8be..019e7f23a 100644 --- a/test/regress/regress1/aufbv/Makefile.am +++ b/test/regress/regress1/aufbv/Makefile.am @@ -17,7 +17,8 @@ endif # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" TESTS = \ - fuzz10.smt + fuzz10.smt \ + bug580.smt2 EXTRA_DIST = $(TESTS) diff --git a/test/regress/regress1/aufbv/bug580.smt2 b/test/regress/regress1/aufbv/bug580.smt2 new file mode 100644 index 000000000..2f2074385 --- /dev/null +++ b/test/regress/regress1/aufbv/bug580.smt2 @@ -0,0 +1,116 @@ +(set-info :source |fuzzsmt|) +(set-info :smt-lib-version 2.0) +(set-info :category "random") +(set-info :status sat) +(set-logic QF_AUFBV) +(declare-fun v0 () (_ BitVec 3)) +(declare-fun a1 () (Array (_ BitVec 3) (_ BitVec 2))) +(declare-fun a2 () (Array (_ BitVec 8) (_ BitVec 1))) +(declare-fun a3 () (Array (_ BitVec 5) (_ BitVec 15))) +(assert (let ((e4(_ bv230 8))) +(let ((e5(_ bv53513 16))) +(let ((e6 (bvurem ((_ zero_extend 8) e4) e5))) +(let ((e7 (ite (bvult e5 ((_ zero_extend 13) v0)) (_ bv1 1) (_ bv0 1)))) +(let ((e8 (store a2 ((_ extract 10 3) e6) ((_ extract 0 0) v0)))) +(let ((e9 (store e8 ((_ zero_extend 5) v0) ((_ extract 13 13) e5)))) +(let ((e10 (store a1 ((_ extract 12 10) e6) ((_ extract 9 8) e6)))) +(let ((e11 (select a2 ((_ zero_extend 7) e7)))) +(let ((e12 (select e9 ((_ sign_extend 5) v0)))) +(let ((e13 (store a3 ((_ zero_extend 2) v0) ((_ extract 14 0) e5)))) +(let ((e14 (select e8 ((_ sign_extend 7) e7)))) +(let ((e15 (store e13 ((_ zero_extend 4) e14) ((_ zero_extend 12) v0)))) +(let ((e16 (ite (= e6 e5) (_ bv1 1) (_ bv0 1)))) +(let ((e17 ((_ sign_extend 15) e16))) +(let ((e18 (ite (bvsle ((_ zero_extend 7) e16) e4) (_ bv1 1) (_ bv0 1)))) +(let ((e19 ((_ rotate_right 0) v0))) +(let ((e20 (bvshl e12 e7))) +(let ((e21 (bvnand e14 e14))) +(let ((e22 (ite (bvugt e7 e18) (_ bv1 1) (_ bv0 1)))) +(let ((e23 ((_ extract 0 0) e11))) +(let ((e24 (distinct ((_ zero_extend 2) e16) e19))) +(let ((e25 (bvslt ((_ zero_extend 13) v0) e5))) +(let ((e26 (bvule e19 ((_ zero_extend 2) e20)))) +(let ((e27 (bvult e17 ((_ zero_extend 15) e11)))) +(let ((e28 (bvult e11 e12))) +(let ((e29 (= e19 ((_ zero_extend 2) e21)))) +(let ((e30 (bvslt e12 e7))) +(let ((e31 (= e21 e7))) +(let ((e32 (bvult e16 e14))) +(let ((e33 (= ((_ sign_extend 7) e23) e4))) +(let ((e34 (bvult ((_ sign_extend 15) e7) e6))) +(let ((e35 (bvsge e14 e23))) +(let ((e36 (bvsgt e17 ((_ zero_extend 15) e23)))) +(let ((e37 (bvult ((_ sign_extend 15) e12) e6))) +(let ((e38 (bvslt e23 e12))) +(let ((e39 (bvule e17 ((_ sign_extend 13) e19)))) +(let ((e40 (distinct ((_ sign_extend 5) e19) e4))) +(let ((e41 (distinct ((_ sign_extend 15) e21) e6))) +(let ((e42 (bvsle ((_ zero_extend 15) e16) e6))) +(let ((e43 (bvsle e12 e23))) +(let ((e44 (bvult e22 e20))) +(let ((e45 (bvule e14 e20))) +(let ((e46 (bvsge ((_ sign_extend 15) e23) e6))) +(let ((e47 (bvugt e6 ((_ zero_extend 15) e20)))) +(let ((e48 (= e17 e17))) +(let ((e49 (bvule ((_ zero_extend 15) e20) e6))) +(let ((e50 (bvsle ((_ sign_extend 15) e11) e17))) +(let ((e51 (distinct ((_ zero_extend 15) e20) e6))) +(let ((e52 (bvsge e23 e7))) +(let ((e53 (bvuge e17 e5))) +(let ((e54 (distinct e12 e23))) +(let ((e55 (bvugt ((_ sign_extend 2) e16) v0))) +(let ((e56 (bvuge e5 e5))) +(let ((e57 (distinct e17 ((_ zero_extend 15) e14)))) +(let ((e58 (distinct ((_ sign_extend 8) e4) e6))) +(let ((e59 (bvugt ((_ sign_extend 15) e12) e6))) +(let ((e60 (bvslt e14 e11))) +(let ((e61 (bvult ((_ sign_extend 13) v0) e17))) +(let ((e62 (bvslt e19 ((_ zero_extend 2) e20)))) +(let ((e63 (= v0 ((_ zero_extend 2) e11)))) +(let ((e64 (bvugt ((_ zero_extend 15) e18) e6))) +(let ((e65 (=> e62 e60))) +(let ((e66 (xor e27 e26))) +(let ((e67 (xor e42 e31))) +(let ((e68 (or e29 e50))) +(let ((e69 (=> e24 e46))) +(let ((e70 (not e54))) +(let ((e71 (=> e58 e55))) +(let ((e72 (and e63 e45))) +(let ((e73 (and e37 e36))) +(let ((e74 (ite e39 e70 e38))) +(let ((e75 (and e64 e34))) +(let ((e76 (or e65 e61))) +(let ((e77 (=> e47 e66))) +(let ((e78 (=> e56 e33))) +(let ((e79 (and e74 e74))) +(let ((e80 (=> e52 e67))) +(let ((e81 (not e41))) +(let ((e82 (ite e79 e69 e43))) +(let ((e83 (and e48 e51))) +(let ((e84 (=> e68 e32))) +(let ((e85 (not e40))) +(let ((e86 (ite e76 e75 e85))) +(let ((e87 (xor e49 e44))) +(let ((e88 (ite e35 e57 e59))) +(let ((e89 (= e25 e87))) +(let ((e90 (=> e82 e73))) +(let ((e91 (=> e78 e72))) +(let ((e92 (= e80 e89))) +(let ((e93 (not e53))) +(let ((e94 (= e84 e77))) +(let ((e95 (and e91 e81))) +(let ((e96 (xor e95 e88))) +(let ((e97 (ite e93 e30 e83))) +(let ((e98 (not e94))) +(let ((e99 (= e98 e96))) +(let ((e100 (and e97 e97))) +(let ((e101 (not e71))) +(let ((e102 (= e92 e99))) +(let ((e103 (and e101 e86))) +(let ((e104 (= e103 e90))) +(let ((e105 (and e102 e100))) +(let ((e106 (ite e104 e28 e105))) +(let ((e107 (and e106 (not (= e5 (_ bv0 16)))))) +e107 +))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) diff --git a/test/regress/regress1/auflia/Makefile.am b/test/regress/regress1/auflia/Makefile.am index a0824e570..25a0d89e0 100644 --- a/test/regress/regress1/auflia/Makefile.am +++ b/test/regress/regress1/auflia/Makefile.am @@ -19,7 +19,8 @@ endif TESTS = \ bug330.smt2 -EXTRA_DIST = $(TESTS) +EXTRA_DIST = $(TESTS) \ + bug337.smt2 # synonyms for "check" in this directory .PHONY: regress regress1 test diff --git a/test/regress/regress1/auflia/bug337.smt2 b/test/regress/regress1/auflia/bug337.smt2 new file mode 100644 index 000000000..b7a564a60 --- /dev/null +++ b/test/regress/regress1/auflia/bug337.smt2 @@ -0,0 +1,524 @@ +(set-logic QF_AUFLIA) +(set-info :source | +Unbounded version of the queue lock algorithm. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun x_0 () Int) +(declare-fun x_1 () Int) +(declare-fun x_2 () (Array Int Int)) +(declare-fun x_3 () Int) +(declare-fun x_4 () Int) +(declare-fun x_5 () Bool) +(declare-fun x_6 () Int) +(declare-fun x_7 () (Array Int Int)) +(declare-fun x_8 () Int) +(declare-fun x_9 () (Array Int Int)) +(declare-fun x_10 () Int) +(declare-fun x_11 () Bool) +(declare-fun x_12 () Int) +(declare-fun x_13 () Int) +(declare-fun x_14 () Int) +(declare-fun x_15 () Int) +(declare-fun x_16 () Int) +(declare-fun x_17 () (Array Int Int)) +(declare-fun x_18 () Int) +(declare-fun x_19 () Int) +(declare-fun x_20 () Int) +(declare-fun x_21 () Int) +(declare-fun x_22 () Int) +(declare-fun x_23 () (Array Int Int)) +(declare-fun x_24 () Int) +(declare-fun x_25 () Bool) +(declare-fun x_26 () Int) +(declare-fun x_27 () Int) +(declare-fun x_28 () Int) +(declare-fun x_29 () Int) +(declare-fun x_30 () Int) +(declare-fun x_31 () (Array Int Int)) +(declare-fun x_32 () Int) +(declare-fun x_33 () Int) +(declare-fun x_34 () Int) +(declare-fun x_35 () Int) +(declare-fun x_36 () Int) +(declare-fun x_37 () (Array Int Int)) +(declare-fun x_38 () Int) +(declare-fun x_39 () Bool) +(declare-fun x_40 () Int) +(declare-fun x_41 () Int) +(declare-fun x_42 () Int) +(declare-fun x_43 () Int) +(declare-fun x_44 () Int) +(declare-fun x_45 () (Array Int Int)) +(declare-fun x_46 () Int) +(declare-fun x_47 () Int) +(declare-fun x_48 () Int) +(declare-fun x_49 () Int) +(declare-fun x_50 () Int) +(declare-fun x_51 () (Array Int Int)) +(declare-fun x_52 () Int) +(declare-fun x_53 () Bool) +(declare-fun x_54 () Int) +(declare-fun x_55 () Int) +(declare-fun x_56 () Int) +(declare-fun x_57 () Int) +(declare-fun x_58 () Int) +(declare-fun x_59 () (Array Int Int)) +(declare-fun x_60 () Int) +(declare-fun x_61 () Int) +(declare-fun x_62 () Int) +(declare-fun x_63 () Int) +(declare-fun x_64 () Int) +(declare-fun x_65 () (Array Int Int)) +(declare-fun x_66 () Int) +(declare-fun x_67 () Bool) +(declare-fun x_68 () Int) +(declare-fun x_69 () Int) +(declare-fun x_70 () Int) +(declare-fun x_71 () Int) +(declare-fun x_72 () Int) +(declare-fun x_73 () (Array Int Int)) +(declare-fun x_74 () Int) +(declare-fun x_75 () Int) +(declare-fun x_76 () Int) +(declare-fun x_77 () Int) +(declare-fun x_78 () Int) +(declare-fun x_79 () (Array Int Int)) +(declare-fun x_80 () Int) +(declare-fun x_81 () Bool) +(declare-fun x_82 () Int) +(declare-fun x_83 () Int) +(declare-fun x_84 () Int) +(declare-fun x_85 () Int) +(declare-fun x_86 () Int) +(declare-fun x_87 () (Array Int Int)) +(declare-fun x_88 () Int) +(declare-fun x_89 () Int) +(declare-fun x_90 () Int) +(declare-fun x_91 () Int) +(declare-fun x_92 () Int) +(declare-fun x_93 () (Array Int Int)) +(declare-fun x_94 () Int) +(declare-fun x_95 () Bool) +(declare-fun x_96 () Int) +(declare-fun x_97 () Int) +(declare-fun x_98 () Int) +(declare-fun x_99 () Int) +(declare-fun x_100 () Int) +(declare-fun x_101 () (Array Int Int)) +(declare-fun x_102 () Int) +(declare-fun x_103 () Int) +(declare-fun x_104 () Int) +(declare-fun x_105 () Int) +(declare-fun x_106 () Int) +(declare-fun x_107 () (Array Int Int)) +(declare-fun x_108 () Int) +(declare-fun x_109 () Bool) +(declare-fun x_110 () Int) +(declare-fun x_111 () Int) +(declare-fun x_112 () Int) +(declare-fun x_113 () Int) +(declare-fun x_114 () Int) +(declare-fun x_115 () (Array Int Int)) +(declare-fun x_116 () Int) +(declare-fun x_117 () Int) +(declare-fun x_118 () Int) +(declare-fun x_119 () Int) +(declare-fun x_120 () Int) +(declare-fun x_121 () (Array Int Int)) +(declare-fun x_122 () Int) +(declare-fun x_123 () Bool) +(declare-fun x_124 () Int) +(declare-fun x_125 () Int) +(declare-fun x_126 () Int) +(declare-fun x_127 () Int) +(declare-fun x_128 () Int) +(declare-fun x_129 () (Array Int Int)) +(declare-fun x_130 () Int) +(declare-fun x_131 () Int) +(declare-fun x_132 () Int) +(declare-fun x_133 () Int) +(declare-fun x_134 () Int) +(declare-fun x_135 () (Array Int Int)) +(declare-fun x_136 () Int) +(declare-fun x_137 () Bool) +(declare-fun x_138 () Int) +(declare-fun x_139 () Int) +(declare-fun x_140 () Int) +(declare-fun x_141 () Int) +(declare-fun x_142 () Int) +(declare-fun x_143 () (Array Int Int)) +(declare-fun x_144 () Int) +(declare-fun x_145 () Int) +(declare-fun x_146 () Int) +(declare-fun x_147 () Int) +(declare-fun x_148 () Int) +(declare-fun x_149 () (Array Int Int)) +(declare-fun x_150 () Int) +(declare-fun x_151 () Bool) +(declare-fun x_152 () Int) +(declare-fun x_153 () Int) +(declare-fun x_154 () Int) +(declare-fun x_155 () Int) +(declare-fun x_156 () Int) +(declare-fun x_157 () (Array Int Int)) +(declare-fun x_158 () Int) +(declare-fun x_159 () Int) +(declare-fun x_160 () Int) +(declare-fun x_161 () Int) +(declare-fun x_162 () Int) +(declare-fun x_163 () (Array Int Int)) +(declare-fun x_164 () Int) +(declare-fun x_165 () Bool) +(declare-fun x_166 () Int) +(declare-fun x_167 () Int) +(declare-fun x_168 () Int) +(declare-fun x_169 () Int) +(declare-fun x_170 () Int) +(declare-fun x_171 () (Array Int Int)) +(declare-fun x_172 () Int) +(declare-fun x_173 () Int) +(declare-fun x_174 () Int) +(declare-fun x_175 () Int) +(declare-fun x_176 () Int) +(declare-fun x_177 () (Array Int Int)) +(declare-fun x_178 () Int) +(declare-fun x_179 () Bool) +(declare-fun x_180 () Int) +(declare-fun x_181 () Int) +(declare-fun x_182 () Int) +(declare-fun x_183 () Int) +(declare-fun x_184 () Int) +(declare-fun x_185 () (Array Int Int)) +(declare-fun x_186 () Int) +(declare-fun x_187 () Int) +(declare-fun x_188 () Int) +(declare-fun x_189 () Int) +(declare-fun x_190 () Int) +(declare-fun x_191 () (Array Int Int)) +(declare-fun x_192 () Int) +(declare-fun x_193 () Bool) +(declare-fun x_194 () Int) +(declare-fun x_195 () Int) +(declare-fun x_196 () Int) +(declare-fun x_197 () Int) +(declare-fun x_198 () Int) +(declare-fun x_199 () (Array Int Int)) +(declare-fun x_200 () Int) +(declare-fun x_201 () Int) +(declare-fun x_202 () Int) +(declare-fun x_203 () Int) +(declare-fun x_204 () Int) +(declare-fun x_205 () (Array Int Int)) +(declare-fun x_206 () Int) +(declare-fun x_207 () Bool) +(declare-fun x_208 () Int) +(declare-fun x_209 () Int) +(declare-fun x_210 () Int) +(declare-fun x_211 () Int) +(declare-fun x_212 () Int) +(declare-fun x_213 () (Array Int Int)) +(declare-fun x_214 () Int) +(declare-fun x_215 () Int) +(declare-fun x_216 () Int) +(declare-fun x_217 () Int) +(declare-fun x_218 () Int) +(declare-fun x_219 () (Array Int Int)) +(declare-fun x_220 () Int) +(declare-fun x_221 () Bool) +(declare-fun x_222 () Int) +(declare-fun x_223 () Int) +(declare-fun x_224 () Int) +(declare-fun x_225 () Int) +(declare-fun x_226 () Int) +(declare-fun x_227 () (Array Int Int)) +(declare-fun x_228 () Int) +(declare-fun x_229 () Int) +(declare-fun x_230 () Int) +(declare-fun x_231 () Int) +(declare-fun x_232 () Int) +(declare-fun x_233 () (Array Int Int)) +(declare-fun x_234 () Int) +(declare-fun x_235 () Bool) +(declare-fun x_236 () Int) +(declare-fun x_237 () Int) +(declare-fun x_238 () Int) +(declare-fun x_239 () Int) +(declare-fun x_240 () Int) +(declare-fun x_241 () (Array Int Int)) +(declare-fun x_242 () Int) +(declare-fun x_243 () Int) +(declare-fun x_244 () Int) +(declare-fun x_245 () Int) +(declare-fun x_246 () Int) +(declare-fun x_247 () (Array Int Int)) +(declare-fun x_248 () Int) +(declare-fun x_249 () Bool) +(declare-fun x_250 () Int) +(declare-fun x_251 () Int) +(declare-fun x_252 () Int) +(declare-fun x_253 () Int) +(declare-fun x_254 () Int) +(declare-fun x_255 () (Array Int Int)) +(declare-fun x_256 () Int) +(declare-fun x_257 () Int) +(declare-fun x_258 () Int) +(declare-fun x_259 () Int) +(declare-fun x_260 () Int) +(declare-fun x_261 () (Array Int Int)) +(declare-fun x_262 () Int) +(declare-fun x_263 () Bool) +(declare-fun x_264 () Int) +(declare-fun x_265 () Int) +(declare-fun x_266 () Int) +(declare-fun x_267 () Int) +(declare-fun x_268 () Int) +(declare-fun x_269 () (Array Int Int)) +(declare-fun x_270 () Int) +(declare-fun x_271 () Int) +(declare-fun x_272 () Int) +(declare-fun x_273 () Int) +(declare-fun x_274 () Int) +(declare-fun x_275 () (Array Int Int)) +(declare-fun x_276 () Int) +(declare-fun x_277 () Bool) +(declare-fun x_278 () Int) +(declare-fun x_279 () Int) +(declare-fun x_280 () Int) +(declare-fun x_281 () Int) +(declare-fun x_282 () Int) +(declare-fun x_283 () (Array Int Int)) +(declare-fun x_284 () Int) +(declare-fun x_285 () Int) +(declare-fun x_286 () Int) +(declare-fun x_287 () Int) +(declare-fun x_288 () Int) +(declare-fun x_289 () (Array Int Int)) +(declare-fun x_290 () Int) +(declare-fun x_291 () Bool) +(declare-fun x_292 () Int) +(declare-fun x_293 () Int) +(declare-fun x_294 () Int) +(declare-fun x_295 () Int) +(declare-fun x_296 () Int) +(declare-fun x_297 () (Array Int Int)) +(declare-fun x_298 () Int) +(declare-fun x_299 () Int) +(declare-fun x_300 () Int) +(declare-fun x_301 () Int) +(declare-fun x_302 () Int) +(declare-fun x_303 () (Array Int Int)) +(declare-fun x_304 () Int) +(declare-fun x_305 () Bool) +(declare-fun x_306 () Int) +(declare-fun x_307 () Int) +(declare-fun x_308 () Int) +(declare-fun x_309 () Int) +(declare-fun x_310 () Int) +(declare-fun x_311 () (Array Int Int)) +(declare-fun x_312 () Int) +(declare-fun x_313 () Int) +(declare-fun x_314 () Int) +(declare-fun x_315 () Int) +(declare-fun x_316 () Int) +(declare-fun x_317 () (Array Int Int)) +(declare-fun x_318 () Int) +(declare-fun x_319 () Bool) +(declare-fun x_320 () Int) +(declare-fun x_321 () Int) +(declare-fun x_322 () Int) +(declare-fun x_323 () Int) +(declare-fun x_324 () Int) +(declare-fun x_325 () (Array Int Int)) +(declare-fun x_326 () Int) +(declare-fun x_327 () Int) +(declare-fun x_328 () Int) +(declare-fun x_329 () Int) +(declare-fun x_330 () Int) +(declare-fun x_331 () (Array Int Int)) +(declare-fun x_332 () Int) +(declare-fun x_333 () Bool) +(declare-fun x_334 () Int) +(declare-fun x_335 () Int) +(declare-fun x_336 () Int) +(declare-fun x_337 () Int) +(declare-fun x_338 () Int) +(declare-fun x_339 () (Array Int Int)) +(declare-fun x_340 () Int) +(declare-fun x_341 () Int) +(declare-fun x_342 () Int) +(declare-fun x_343 () Int) +(declare-fun x_344 () Int) +(declare-fun x_345 () (Array Int Int)) +(declare-fun x_346 () Int) +(declare-fun x_347 () Bool) +(declare-fun x_348 () Int) +(declare-fun x_349 () Int) +(declare-fun x_350 () Int) +(declare-fun x_351 () Int) +(declare-fun x_352 () Int) +(declare-fun x_353 () (Array Int Int)) +(declare-fun x_354 () Int) +(declare-fun x_355 () Int) +(declare-fun x_356 () Int) +(declare-fun x_357 () Int) +(declare-fun x_358 () Int) +(declare-fun x_359 () Int) +(declare-fun x_360 () Int) +(declare-fun x_361 () Int) +(declare-fun x_362 () Int) +(declare-fun x_363 () Int) +(declare-fun x_364 () Int) +(declare-fun x_365 () Int) +(declare-fun x_366 () Int) +(declare-fun x_367 () Int) +(declare-fun x_368 () Int) +(declare-fun x_369 () Int) +(declare-fun x_370 () Int) +(declare-fun x_371 () Int) +(declare-fun x_372 () Int) +(declare-fun x_373 () Int) +(declare-fun x_374 () Int) +(declare-fun x_375 () Int) +(declare-fun x_376 () Int) +(declare-fun x_377 () Int) +(declare-fun x_378 () Int) +(declare-fun x_379 () Int) +(declare-fun x_380 () Int) +(declare-fun x_381 () Int) +(declare-fun x_382 () Int) +(declare-fun x_383 () Int) +(declare-fun x_384 () Int) +(declare-fun x_385 () Int) +(declare-fun x_386 () Int) +(declare-fun x_387 () Int) +(declare-fun x_388 () Int) +(declare-fun x_389 () Int) +(declare-fun x_390 () Int) +(declare-fun x_391 () Int) +(declare-fun x_392 () Int) +(declare-fun x_393 () Int) +(declare-fun x_394 () Int) +(declare-fun x_395 () Int) +(declare-fun x_396 () Int) +(declare-fun x_397 () Int) +(declare-fun x_398 () Int) +(declare-fun x_399 () Int) +(declare-fun x_400 () Int) +(declare-fun x_401 () Int) +(declare-fun x_402 () Int) +(declare-fun x_403 () Int) +(declare-fun x_404 () Int) +(declare-fun x_405 () Int) +(declare-fun x_406 () Int) +(declare-fun x_407 () Int) +(declare-fun x_408 () Int) +(declare-fun x_409 () Int) +(declare-fun x_410 () Int) +(declare-fun x_411 () Int) +(declare-fun x_412 () Int) +(declare-fun x_413 () Int) +(declare-fun x_414 () Int) +(declare-fun x_415 () Int) +(declare-fun x_416 () Int) +(declare-fun x_417 () Int) +(declare-fun x_418 () Int) +(declare-fun x_419 () Int) +(declare-fun x_420 () Int) +(declare-fun x_421 () Int) +(declare-fun x_422 () Int) +(declare-fun x_423 () Int) +(declare-fun x_424 () Int) +(declare-fun x_425 () Int) +(declare-fun x_426 () Int) +(declare-fun x_427 () Int) +(declare-fun x_428 () Int) +(declare-fun x_429 () Int) +(declare-fun x_430 () Int) +(declare-fun x_431 () Int) +(declare-fun x_432 () Int) +(declare-fun x_433 () Int) +(declare-fun x_434 () Int) +(declare-fun x_435 () Int) +(declare-fun x_436 () Int) +(declare-fun x_437 () Int) +(declare-fun x_438 () Int) +(declare-fun x_439 () Int) +(declare-fun x_440 () Int) +(declare-fun x_441 () Int) +(declare-fun x_442 () Int) +(declare-fun x_443 () Int) +(declare-fun x_444 () Int) +(declare-fun x_445 () Int) +(declare-fun x_446 () Int) +(declare-fun x_447 () Int) +(declare-fun x_448 () Int) +(declare-fun x_449 () Int) +(declare-fun x_450 () Int) +(declare-fun x_451 () Int) +(declare-fun x_452 () Int) +(declare-fun x_453 () Int) +(declare-fun x_454 () Int) +(declare-fun x_455 () Int) +(declare-fun x_456 () Int) +(declare-fun x_457 () Int) +(declare-fun x_458 () Int) +(declare-fun x_459 () Int) +(declare-fun x_460 () Int) +(declare-fun x_461 () Int) +(declare-fun x_462 () Int) +(declare-fun x_463 () Int) +(declare-fun x_464 () Int) +(declare-fun x_465 () Int) +(declare-fun x_466 () Int) +(declare-fun x_467 () Int) +(declare-fun x_468 () Int) +(declare-fun x_469 () Int) +(declare-fun x_470 () Int) +(declare-fun x_471 () Int) +(declare-fun x_472 () Int) +(declare-fun x_473 () Int) +(declare-fun x_474 () Int) +(declare-fun x_475 () Int) +(declare-fun x_476 () Int) +(declare-fun x_477 () Int) +(declare-fun x_478 () Int) +(declare-fun x_479 () Int) +(declare-fun x_480 () Int) +(declare-fun x_481 () Int) +(declare-fun x_482 () Int) +(declare-fun x_483 () Int) +(declare-fun x_484 () Int) +(declare-fun x_485 () Int) +(declare-fun x_486 () Int) +(declare-fun x_487 () Int) +(declare-fun x_488 () Int) +(declare-fun x_489 () Int) +(declare-fun x_490 () Int) +(declare-fun x_491 () Int) +(declare-fun x_492 () Int) +(declare-fun x_493 () Int) +(declare-fun x_494 () Int) +(declare-fun x_495 () Int) +(declare-fun x_496 () Int) +(declare-fun x_497 () Int) +(declare-fun x_498 () Int) +(declare-fun x_499 () Int) +(declare-fun x_500 () Int) +(declare-fun x_501 () Int) +(declare-fun x_502 () Int) +(declare-fun x_503 () Int) +(declare-fun x_504 () Int) +(declare-fun x_505 () Int) +(declare-fun x_506 () Int) +(declare-fun x_507 () Int) +(declare-fun x_508 () Int) +(declare-fun x_509 () Int) +(declare-fun x_510 () Int) +(declare-fun x_511 () Int) +(assert (let ((?v_123 (= x_9 x_7)) (?v_120 (= x_10 x_0)) (?v_121 (= x_11 x_5)) (?v_124 (= x_12 x_1)) (?v_122 (not (<= x_1 x_0))) (?v_118 (= x_23 x_9)) (?v_115 (= x_24 x_10)) (?v_116 (= x_25 x_11)) (?v_119 (= x_26 x_12)) (?v_117 (not (<= x_12 x_10))) (?v_113 (= x_37 x_23)) (?v_110 (= x_38 x_24)) (?v_111 (= x_39 x_25)) (?v_114 (= x_40 x_26)) (?v_112 (not (<= x_26 x_24))) (?v_108 (= x_51 x_37)) (?v_105 (= x_52 x_38)) (?v_106 (= x_53 x_39)) (?v_109 (= x_54 x_40)) (?v_107 (not (<= x_40 x_38))) (?v_103 (= x_65 x_51)) (?v_100 (= x_66 x_52)) (?v_101 (= x_67 x_53)) (?v_104 (= x_68 x_54)) (?v_102 (not (<= x_54 x_52))) (?v_98 (= x_79 x_65)) (?v_95 (= x_80 x_66)) (?v_96 (= x_81 x_67)) (?v_99 (= x_82 x_68)) (?v_97 (not (<= x_68 x_66))) (?v_93 (= x_93 x_79)) (?v_90 (= x_94 x_80)) (?v_91 (= x_95 x_81)) (?v_94 (= x_96 x_82)) (?v_92 (not (<= x_82 x_80))) (?v_88 (= x_107 x_93)) (?v_85 (= x_108 x_94)) (?v_86 (= x_109 x_95)) (?v_89 (= x_110 x_96)) (?v_87 (not (<= x_96 x_94))) (?v_83 (= x_121 x_107)) (?v_80 (= x_122 x_108)) (?v_81 (= x_123 x_109)) (?v_84 (= x_124 x_110)) (?v_82 (not (<= x_110 x_108))) (?v_78 (= x_135 x_121)) (?v_75 (= x_136 x_122)) (?v_76 (= x_137 x_123)) (?v_79 (= x_138 x_124)) (?v_77 (not (<= x_124 x_122))) (?v_73 (= x_149 x_135)) (?v_70 (= x_150 x_136)) (?v_71 (= x_151 x_137)) (?v_74 (= x_152 x_138)) (?v_72 (not (<= x_138 x_136))) (?v_68 (= x_163 x_149)) (?v_65 (= x_164 x_150)) (?v_66 (= x_165 x_151)) (?v_69 (= x_166 x_152)) (?v_67 (not (<= x_152 x_150))) (?v_63 (= x_177 x_163)) (?v_60 (= x_178 x_164)) (?v_61 (= x_179 x_165)) (?v_64 (= x_180 x_166)) (?v_62 (not (<= x_166 x_164))) (?v_58 (= x_191 x_177)) (?v_55 (= x_192 x_178)) (?v_56 (= x_193 x_179)) (?v_59 (= x_194 x_180)) (?v_57 (not (<= x_180 x_178))) (?v_53 (= x_205 x_191)) (?v_50 (= x_206 x_192)) (?v_51 (= x_207 x_193)) (?v_54 (= x_208 x_194)) (?v_52 (not (<= x_194 x_192))) (?v_48 (= x_219 x_205)) (?v_45 (= x_220 x_206)) (?v_46 (= x_221 x_207)) (?v_49 (= x_222 x_208)) (?v_47 (not (<= x_208 x_206))) (?v_43 (= x_233 x_219)) (?v_40 (= x_234 x_220)) (?v_41 (= x_235 x_221)) (?v_44 (= x_236 x_222)) (?v_42 (not (<= x_222 x_220))) (?v_38 (= x_247 x_233)) (?v_35 (= x_248 x_234)) (?v_36 (= x_249 x_235)) (?v_39 (= x_250 x_236)) (?v_37 (not (<= x_236 x_234))) (?v_33 (= x_261 x_247)) (?v_30 (= x_262 x_248)) (?v_31 (= x_263 x_249)) (?v_34 (= x_264 x_250)) (?v_32 (not (<= x_250 x_248))) (?v_28 (= x_275 x_261)) (?v_25 (= x_276 x_262)) (?v_26 (= x_277 x_263)) (?v_29 (= x_278 x_264)) (?v_27 (not (<= x_264 x_262))) (?v_23 (= x_289 x_275)) (?v_20 (= x_290 x_276)) (?v_21 (= x_291 x_277)) (?v_24 (= x_292 x_278)) (?v_22 (not (<= x_278 x_276))) (?v_18 (= x_303 x_289)) (?v_15 (= x_304 x_290)) (?v_16 (= x_305 x_291)) (?v_19 (= x_306 x_292)) (?v_17 (not (<= x_292 x_290))) (?v_13 (= x_317 x_303)) (?v_10 (= x_318 x_304)) (?v_11 (= x_319 x_305)) (?v_14 (= x_320 x_306)) (?v_12 (not (<= x_306 x_304))) (?v_8 (= x_331 x_317)) (?v_5 (= x_332 x_318)) (?v_6 (= x_333 x_319)) (?v_9 (= x_334 x_320)) (?v_7 (not (<= x_320 x_318))) (?v_3 (= x_345 x_331)) (?v_0 (= x_346 x_332)) (?v_1 (= x_347 x_333)) (?v_4 (= x_348 x_334)) (?v_2 (not (<= x_334 x_332))) (?v_125 (select x_2 x_3)) (?v_126 (select x_2 x_4))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= x_4 x_3)) (= x_0 0)) (= x_1 0)) (= x_358 ?v_125)) (= x_358 1)) (= x_359 ?v_126)) (= x_359 1)) x_5) (= x_6 0)) (= x_360 (select x_7 x_0))) (= x_8 x_360)) (= x_361 (select x_9 x_10))) (= x_22 x_361)) (= x_362 (select x_23 x_24))) (= x_36 x_362)) (= x_363 (select x_37 x_38))) (= x_50 x_363)) (= x_364 (select x_51 x_52))) (= x_64 x_364)) (= x_365 (select x_65 x_66))) (= x_78 x_365)) (= x_366 (select x_79 x_80))) (= x_92 x_366)) (= x_367 (select x_93 x_94))) (= x_106 x_367)) (= x_368 (select x_107 x_108))) (= x_120 x_368)) (= x_369 (select x_121 x_122))) (= x_134 x_369)) (= x_370 (select x_135 x_136))) (= x_148 x_370)) (= x_371 (select x_149 x_150))) (= x_162 x_371)) (= x_372 (select x_163 x_164))) (= x_176 x_372)) (= x_373 (select x_177 x_178))) (= x_190 x_373)) (= x_374 (select x_191 x_192))) (= x_204 x_374)) (= x_375 (select x_205 x_206))) (= x_218 x_375)) (= x_376 (select x_219 x_220))) (= x_232 x_376)) (= x_377 (select x_233 x_234))) (= x_246 x_377)) (= x_378 (select x_247 x_248))) (= x_260 x_378)) (= x_379 (select x_261 x_262))) (= x_274 x_379)) (= x_380 (select x_275 x_276))) (= x_288 x_380)) (= x_381 (select x_289 x_290))) (= x_302 x_381)) (= x_382 (select x_303 x_304))) (= x_316 x_382)) (= x_383 (select x_317 x_318))) (= x_330 x_383)) (= x_384 (select x_331 x_332))) (= x_344 x_384)) (= x_349 (+ x_335 1))) (= x_385 (select x_339 x_351))) (= x_386 (select x_339 x_354))) (= x_387 (select x_339 x_356))) (or (or (or (and (and (and (and (and (and (and (= x_350 0) (= x_348 (+ x_334 1))) ?v_0) ?v_1) (= x_352 x_351)) (= x_385 1)) (= x_353 (store x_339 x_351 2))) (= x_345 (store x_331 x_334 x_351))) (and (and (and (and (and (and (and (and (and (= x_350 1) ?v_2) ?v_0) ?v_1) ?v_3) ?v_4) (= x_355 x_354)) (= x_386 2)) (= x_344 x_354)) (= x_353 (store x_339 x_354 3)))) (and (and (and (and (and (and (and (and (and (= x_350 2) ?v_2) (= x_346 (+ x_332 1))) ?v_1) ?v_3) ?v_4) (= x_357 x_356)) (= x_387 3)) (or (not (<= x_335 12)) (= x_344 x_356))) (= x_353 (store x_339 x_356 1)))) (and (and (and (and (and (= x_350 3) ?v_3) ?v_0) ?v_1) (= x_353 x_339)) ?v_4))) (= x_335 (+ x_321 1))) (= x_388 (select x_325 x_337))) (= x_389 (select x_325 x_340))) (= x_390 (select x_325 x_342))) (or (or (or (and (and (and (and (and (and (and (= x_336 0) (= x_334 (+ x_320 1))) ?v_5) ?v_6) (= x_338 x_337)) (= x_388 1)) (= x_339 (store x_325 x_337 2))) (= x_331 (store x_317 x_320 x_337))) (and (and (and (and (and (and (and (and (and (= x_336 1) ?v_7) ?v_5) ?v_6) ?v_8) ?v_9) (= x_341 x_340)) (= x_389 2)) (= x_330 x_340)) (= x_339 (store x_325 x_340 3)))) (and (and (and (and (and (and (and (and (and (= x_336 2) ?v_7) (= x_332 (+ x_318 1))) ?v_6) ?v_8) ?v_9) (= x_343 x_342)) (= x_390 3)) (or (not (<= x_321 12)) (= x_330 x_342))) (= x_339 (store x_325 x_342 1)))) (and (and (and (and (and (= x_336 3) ?v_8) ?v_5) ?v_6) (= x_339 x_325)) ?v_9))) (= x_321 (+ x_307 1))) (= x_391 (select x_311 x_323))) (= x_392 (select x_311 x_326))) (= x_393 (select x_311 x_328))) (or (or (or (and (and (and (and (and (and (and (= x_322 0) (= x_320 (+ x_306 1))) ?v_10) ?v_11) (= x_324 x_323)) (= x_391 1)) (= x_325 (store x_311 x_323 2))) (= x_317 (store x_303 x_306 x_323))) (and (and (and (and (and (and (and (and (and (= x_322 1) ?v_12) ?v_10) ?v_11) ?v_13) ?v_14) (= x_327 x_326)) (= x_392 2)) (= x_316 x_326)) (= x_325 (store x_311 x_326 3)))) (and (and (and (and (and (and (and (and (and (= x_322 2) ?v_12) (= x_318 (+ x_304 1))) ?v_11) ?v_13) ?v_14) (= x_329 x_328)) (= x_393 3)) (or (not (<= x_307 12)) (= x_316 x_328))) (= x_325 (store x_311 x_328 1)))) (and (and (and (and (and (= x_322 3) ?v_13) ?v_10) ?v_11) (= x_325 x_311)) ?v_14))) (= x_307 (+ x_293 1))) (= x_394 (select x_297 x_309))) (= x_395 (select x_297 x_312))) (= x_396 (select x_297 x_314))) (or (or (or (and (and (and (and (and (and (and (= x_308 0) (= x_306 (+ x_292 1))) ?v_15) ?v_16) (= x_310 x_309)) (= x_394 1)) (= x_311 (store x_297 x_309 2))) (= x_303 (store x_289 x_292 x_309))) (and (and (and (and (and (and (and (and (and (= x_308 1) ?v_17) ?v_15) ?v_16) ?v_18) ?v_19) (= x_313 x_312)) (= x_395 2)) (= x_302 x_312)) (= x_311 (store x_297 x_312 3)))) (and (and (and (and (and (and (and (and (and (= x_308 2) ?v_17) (= x_304 (+ x_290 1))) ?v_16) ?v_18) ?v_19) (= x_315 x_314)) (= x_396 3)) (or (not (<= x_293 12)) (= x_302 x_314))) (= x_311 (store x_297 x_314 1)))) (and (and (and (and (and (= x_308 3) ?v_18) ?v_15) ?v_16) (= x_311 x_297)) ?v_19))) (= x_293 (+ x_279 1))) (= x_397 (select x_283 x_295))) (= x_398 (select x_283 x_298))) (= x_399 (select x_283 x_300))) (or (or (or (and (and (and (and (and (and (and (= x_294 0) (= x_292 (+ x_278 1))) ?v_20) ?v_21) (= x_296 x_295)) (= x_397 1)) (= x_297 (store x_283 x_295 2))) (= x_289 (store x_275 x_278 x_295))) (and (and (and (and (and (and (and (and (and (= x_294 1) ?v_22) ?v_20) ?v_21) ?v_23) ?v_24) (= x_299 x_298)) (= x_398 2)) (= x_288 x_298)) (= x_297 (store x_283 x_298 3)))) (and (and (and (and (and (and (and (and (and (= x_294 2) ?v_22) (= x_290 (+ x_276 1))) ?v_21) ?v_23) ?v_24) (= x_301 x_300)) (= x_399 3)) (or (not (<= x_279 12)) (= x_288 x_300))) (= x_297 (store x_283 x_300 1)))) (and (and (and (and (and (= x_294 3) ?v_23) ?v_20) ?v_21) (= x_297 x_283)) ?v_24))) (= x_279 (+ x_265 1))) (= x_400 (select x_269 x_281))) (= x_401 (select x_269 x_284))) (= x_402 (select x_269 x_286))) (or (or (or (and (and (and (and (and (and (and (= x_280 0) (= x_278 (+ x_264 1))) ?v_25) ?v_26) (= x_282 x_281)) (= x_400 1)) (= x_283 (store x_269 x_281 2))) (= x_275 (store x_261 x_264 x_281))) (and (and (and (and (and (and (and (and (and (= x_280 1) ?v_27) ?v_25) ?v_26) ?v_28) ?v_29) (= x_285 x_284)) (= x_401 2)) (= x_274 x_284)) (= x_283 (store x_269 x_284 3)))) (and (and (and (and (and (and (and (and (and (= x_280 2) ?v_27) (= x_276 (+ x_262 1))) ?v_26) ?v_28) ?v_29) (= x_287 x_286)) (= x_402 3)) (or (not (<= x_265 12)) (= x_274 x_286))) (= x_283 (store x_269 x_286 1)))) (and (and (and (and (and (= x_280 3) ?v_28) ?v_25) ?v_26) (= x_283 x_269)) ?v_29))) (= x_265 (+ x_251 1))) (= x_403 (select x_255 x_267))) (= x_404 (select x_255 x_270))) (= x_405 (select x_255 x_272))) (or (or (or (and (and (and (and (and (and (and (= x_266 0) (= x_264 (+ x_250 1))) ?v_30) ?v_31) (= x_268 x_267)) (= x_403 1)) (= x_269 (store x_255 x_267 2))) (= x_261 (store x_247 x_250 x_267))) (and (and (and (and (and (and (and (and (and (= x_266 1) ?v_32) ?v_30) ?v_31) ?v_33) ?v_34) (= x_271 x_270)) (= x_404 2)) (= x_260 x_270)) (= x_269 (store x_255 x_270 3)))) (and (and (and (and (and (and (and (and (and (= x_266 2) ?v_32) (= x_262 (+ x_248 1))) ?v_31) ?v_33) ?v_34) (= x_273 x_272)) (= x_405 3)) (or (not (<= x_251 12)) (= x_260 x_272))) (= x_269 (store x_255 x_272 1)))) (and (and (and (and (and (= x_266 3) ?v_33) ?v_30) ?v_31) (= x_269 x_255)) ?v_34))) (= x_251 (+ x_237 1))) (= x_406 (select x_241 x_253))) (= x_407 (select x_241 x_256))) (= x_408 (select x_241 x_258))) (or (or (or (and (and (and (and (and (and (and (= x_252 0) (= x_250 (+ x_236 1))) ?v_35) ?v_36) (= x_254 x_253)) (= x_406 1)) (= x_255 (store x_241 x_253 2))) (= x_247 (store x_233 x_236 x_253))) (and (and (and (and (and (and (and (and (and (= x_252 1) ?v_37) ?v_35) ?v_36) ?v_38) ?v_39) (= x_257 x_256)) (= x_407 2)) (= x_246 x_256)) (= x_255 (store x_241 x_256 3)))) (and (and (and (and (and (and (and (and (and (= x_252 2) ?v_37) (= x_248 (+ x_234 1))) ?v_36) ?v_38) ?v_39) (= x_259 x_258)) (= x_408 3)) (or (not (<= x_237 12)) (= x_246 x_258))) (= x_255 (store x_241 x_258 1)))) (and (and (and (and (and (= x_252 3) ?v_38) ?v_35) ?v_36) (= x_255 x_241)) ?v_39))) (= x_237 (+ x_223 1))) (= x_409 (select x_227 x_239))) (= x_410 (select x_227 x_242))) (= x_411 (select x_227 x_244))) (or (or (or (and (and (and (and (and (and (and (= x_238 0) (= x_236 (+ x_222 1))) ?v_40) ?v_41) (= x_240 x_239)) (= x_409 1)) (= x_241 (store x_227 x_239 2))) (= x_233 (store x_219 x_222 x_239))) (and (and (and (and (and (and (and (and (and (= x_238 1) ?v_42) ?v_40) ?v_41) ?v_43) ?v_44) (= x_243 x_242)) (= x_410 2)) (= x_232 x_242)) (= x_241 (store x_227 x_242 3)))) (and (and (and (and (and (and (and (and (and (= x_238 2) ?v_42) (= x_234 (+ x_220 1))) ?v_41) ?v_43) ?v_44) (= x_245 x_244)) (= x_411 3)) (or (not (<= x_223 12)) (= x_232 x_244))) (= x_241 (store x_227 x_244 1)))) (and (and (and (and (and (= x_238 3) ?v_43) ?v_40) ?v_41) (= x_241 x_227)) ?v_44))) (= x_223 (+ x_209 1))) (= x_412 (select x_213 x_225))) (= x_413 (select x_213 x_228))) (= x_414 (select x_213 x_230))) (or (or (or (and (and (and (and (and (and (and (= x_224 0) (= x_222 (+ x_208 1))) ?v_45) ?v_46) (= x_226 x_225)) (= x_412 1)) (= x_227 (store x_213 x_225 2))) (= x_219 (store x_205 x_208 x_225))) (and (and (and (and (and (and (and (and (and (= x_224 1) ?v_47) ?v_45) ?v_46) ?v_48) ?v_49) (= x_229 x_228)) (= x_413 2)) (= x_218 x_228)) (= x_227 (store x_213 x_228 3)))) (and (and (and (and (and (and (and (and (and (= x_224 2) ?v_47) (= x_220 (+ x_206 1))) ?v_46) ?v_48) ?v_49) (= x_231 x_230)) (= x_414 3)) (or (not (<= x_209 12)) (= x_218 x_230))) (= x_227 (store x_213 x_230 1)))) (and (and (and (and (and (= x_224 3) ?v_48) ?v_45) ?v_46) (= x_227 x_213)) ?v_49))) (= x_209 (+ x_195 1))) (= x_415 (select x_199 x_211))) (= x_416 (select x_199 x_214))) (= x_417 (select x_199 x_216))) (or (or (or (and (and (and (and (and (and (and (= x_210 0) (= x_208 (+ x_194 1))) ?v_50) ?v_51) (= x_212 x_211)) (= x_415 1)) (= x_213 (store x_199 x_211 2))) (= x_205 (store x_191 x_194 x_211))) (and (and (and (and (and (and (and (and (and (= x_210 1) ?v_52) ?v_50) ?v_51) ?v_53) ?v_54) (= x_215 x_214)) (= x_416 2)) (= x_204 x_214)) (= x_213 (store x_199 x_214 3)))) (and (and (and (and (and (and (and (and (and (= x_210 2) ?v_52) (= x_206 (+ x_192 1))) ?v_51) ?v_53) ?v_54) (= x_217 x_216)) (= x_417 3)) (or (not (<= x_195 12)) (= x_204 x_216))) (= x_213 (store x_199 x_216 1)))) (and (and (and (and (and (= x_210 3) ?v_53) ?v_50) ?v_51) (= x_213 x_199)) ?v_54))) (= x_195 (+ x_181 1))) (= x_418 (select x_185 x_197))) (= x_419 (select x_185 x_200))) (= x_420 (select x_185 x_202))) (or (or (or (and (and (and (and (and (and (and (= x_196 0) (= x_194 (+ x_180 1))) ?v_55) ?v_56) (= x_198 x_197)) (= x_418 1)) (= x_199 (store x_185 x_197 2))) (= x_191 (store x_177 x_180 x_197))) (and (and (and (and (and (and (and (and (and (= x_196 1) ?v_57) ?v_55) ?v_56) ?v_58) ?v_59) (= x_201 x_200)) (= x_419 2)) (= x_190 x_200)) (= x_199 (store x_185 x_200 3)))) (and (and (and (and (and (and (and (and (and (= x_196 2) ?v_57) (= x_192 (+ x_178 1))) ?v_56) ?v_58) ?v_59) (= x_203 x_202)) (= x_420 3)) (or (not (<= x_181 12)) (= x_190 x_202))) (= x_199 (store x_185 x_202 1)))) (and (and (and (and (and (= x_196 3) ?v_58) ?v_55) ?v_56) (= x_199 x_185)) ?v_59))) (= x_181 (+ x_167 1))) (= x_421 (select x_171 x_183))) (= x_422 (select x_171 x_186))) (= x_423 (select x_171 x_188))) (or (or (or (and (and (and (and (and (and (and (= x_182 0) (= x_180 (+ x_166 1))) ?v_60) ?v_61) (= x_184 x_183)) (= x_421 1)) (= x_185 (store x_171 x_183 2))) (= x_177 (store x_163 x_166 x_183))) (and (and (and (and (and (and (and (and (and (= x_182 1) ?v_62) ?v_60) ?v_61) ?v_63) ?v_64) (= x_187 x_186)) (= x_422 2)) (= x_176 x_186)) (= x_185 (store x_171 x_186 3)))) (and (and (and (and (and (and (and (and (and (= x_182 2) ?v_62) (= x_178 (+ x_164 1))) ?v_61) ?v_63) ?v_64) (= x_189 x_188)) (= x_423 3)) (or (not (<= x_167 12)) (= x_176 x_188))) (= x_185 (store x_171 x_188 1)))) (and (and (and (and (and (= x_182 3) ?v_63) ?v_60) ?v_61) (= x_185 x_171)) ?v_64))) (= x_167 (+ x_153 1))) (= x_424 (select x_157 x_169))) (= x_425 (select x_157 x_172))) (= x_426 (select x_157 x_174))) (or (or (or (and (and (and (and (and (and (and (= x_168 0) (= x_166 (+ x_152 1))) ?v_65) ?v_66) (= x_170 x_169)) (= x_424 1)) (= x_171 (store x_157 x_169 2))) (= x_163 (store x_149 x_152 x_169))) (and (and (and (and (and (and (and (and (and (= x_168 1) ?v_67) ?v_65) ?v_66) ?v_68) ?v_69) (= x_173 x_172)) (= x_425 2)) (= x_162 x_172)) (= x_171 (store x_157 x_172 3)))) (and (and (and (and (and (and (and (and (and (= x_168 2) ?v_67) (= x_164 (+ x_150 1))) ?v_66) ?v_68) ?v_69) (= x_175 x_174)) (= x_426 3)) (or (not (<= x_153 12)) (= x_162 x_174))) (= x_171 (store x_157 x_174 1)))) (and (and (and (and (and (= x_168 3) ?v_68) ?v_65) ?v_66) (= x_171 x_157)) ?v_69))) (= x_153 (+ x_139 1))) (= x_427 (select x_143 x_155))) (= x_428 (select x_143 x_158))) (= x_429 (select x_143 x_160))) (or (or (or (and (and (and (and (and (and (and (= x_154 0) (= x_152 (+ x_138 1))) ?v_70) ?v_71) (= x_156 x_155)) (= x_427 1)) (= x_157 (store x_143 x_155 2))) (= x_149 (store x_135 x_138 x_155))) (and (and (and (and (and (and (and (and (and (= x_154 1) ?v_72) ?v_70) ?v_71) ?v_73) ?v_74) (= x_159 x_158)) (= x_428 2)) (= x_148 x_158)) (= x_157 (store x_143 x_158 3)))) (and (and (and (and (and (and (and (and (and (= x_154 2) ?v_72) (= x_150 (+ x_136 1))) ?v_71) ?v_73) ?v_74) (= x_161 x_160)) (= x_429 3)) (or (not (<= x_139 12)) (= x_148 x_160))) (= x_157 (store x_143 x_160 1)))) (and (and (and (and (and (= x_154 3) ?v_73) ?v_70) ?v_71) (= x_157 x_143)) ?v_74))) (= x_139 (+ x_125 1))) (= x_430 (select x_129 x_141))) (= x_431 (select x_129 x_144))) (= x_432 (select x_129 x_146))) (or (or (or (and (and (and (and (and (and (and (= x_140 0) (= x_138 (+ x_124 1))) ?v_75) ?v_76) (= x_142 x_141)) (= x_430 1)) (= x_143 (store x_129 x_141 2))) (= x_135 (store x_121 x_124 x_141))) (and (and (and (and (and (and (and (and (and (= x_140 1) ?v_77) ?v_75) ?v_76) ?v_78) ?v_79) (= x_145 x_144)) (= x_431 2)) (= x_134 x_144)) (= x_143 (store x_129 x_144 3)))) (and (and (and (and (and (and (and (and (and (= x_140 2) ?v_77) (= x_136 (+ x_122 1))) ?v_76) ?v_78) ?v_79) (= x_147 x_146)) (= x_432 3)) (or (not (<= x_125 12)) (= x_134 x_146))) (= x_143 (store x_129 x_146 1)))) (and (and (and (and (and (= x_140 3) ?v_78) ?v_75) ?v_76) (= x_143 x_129)) ?v_79))) (= x_125 (+ x_111 1))) (= x_433 (select x_115 x_127))) (= x_434 (select x_115 x_130))) (= x_435 (select x_115 x_132))) (or (or (or (and (and (and (and (and (and (and (= x_126 0) (= x_124 (+ x_110 1))) ?v_80) ?v_81) (= x_128 x_127)) (= x_433 1)) (= x_129 (store x_115 x_127 2))) (= x_121 (store x_107 x_110 x_127))) (and (and (and (and (and (and (and (and (and (= x_126 1) ?v_82) ?v_80) ?v_81) ?v_83) ?v_84) (= x_131 x_130)) (= x_434 2)) (= x_120 x_130)) (= x_129 (store x_115 x_130 3)))) (and (and (and (and (and (and (and (and (and (= x_126 2) ?v_82) (= x_122 (+ x_108 1))) ?v_81) ?v_83) ?v_84) (= x_133 x_132)) (= x_435 3)) (or (not (<= x_111 12)) (= x_120 x_132))) (= x_129 (store x_115 x_132 1)))) (and (and (and (and (and (= x_126 3) ?v_83) ?v_80) ?v_81) (= x_129 x_115)) ?v_84))) (= x_111 (+ x_97 1))) (= x_436 (select x_101 x_113))) (= x_437 (select x_101 x_116))) (= x_438 (select x_101 x_118))) (or (or (or (and (and (and (and (and (and (and (= x_112 0) (= x_110 (+ x_96 1))) ?v_85) ?v_86) (= x_114 x_113)) (= x_436 1)) (= x_115 (store x_101 x_113 2))) (= x_107 (store x_93 x_96 x_113))) (and (and (and (and (and (and (and (and (and (= x_112 1) ?v_87) ?v_85) ?v_86) ?v_88) ?v_89) (= x_117 x_116)) (= x_437 2)) (= x_106 x_116)) (= x_115 (store x_101 x_116 3)))) (and (and (and (and (and (and (and (and (and (= x_112 2) ?v_87) (= x_108 (+ x_94 1))) ?v_86) ?v_88) ?v_89) (= x_119 x_118)) (= x_438 3)) (or (not (<= x_97 12)) (= x_106 x_118))) (= x_115 (store x_101 x_118 1)))) (and (and (and (and (and (= x_112 3) ?v_88) ?v_85) ?v_86) (= x_115 x_101)) ?v_89))) (= x_97 (+ x_83 1))) (= x_439 (select x_87 x_99))) (= x_440 (select x_87 x_102))) (= x_441 (select x_87 x_104))) (or (or (or (and (and (and (and (and (and (and (= x_98 0) (= x_96 (+ x_82 1))) ?v_90) ?v_91) (= x_100 x_99)) (= x_439 1)) (= x_101 (store x_87 x_99 2))) (= x_93 (store x_79 x_82 x_99))) (and (and (and (and (and (and (and (and (and (= x_98 1) ?v_92) ?v_90) ?v_91) ?v_93) ?v_94) (= x_103 x_102)) (= x_440 2)) (= x_92 x_102)) (= x_101 (store x_87 x_102 3)))) (and (and (and (and (and (and (and (and (and (= x_98 2) ?v_92) (= x_94 (+ x_80 1))) ?v_91) ?v_93) ?v_94) (= x_105 x_104)) (= x_441 3)) (or (not (<= x_83 12)) (= x_92 x_104))) (= x_101 (store x_87 x_104 1)))) (and (and (and (and (and (= x_98 3) ?v_93) ?v_90) ?v_91) (= x_101 x_87)) ?v_94))) (= x_83 (+ x_69 1))) (= x_442 (select x_73 x_85))) (= x_443 (select x_73 x_88))) (= x_444 (select x_73 x_90))) (or (or (or (and (and (and (and (and (and (and (= x_84 0) (= x_82 (+ x_68 1))) ?v_95) ?v_96) (= x_86 x_85)) (= x_442 1)) (= x_87 (store x_73 x_85 2))) (= x_79 (store x_65 x_68 x_85))) (and (and (and (and (and (and (and (and (and (= x_84 1) ?v_97) ?v_95) ?v_96) ?v_98) ?v_99) (= x_89 x_88)) (= x_443 2)) (= x_78 x_88)) (= x_87 (store x_73 x_88 3)))) (and (and (and (and (and (and (and (and (and (= x_84 2) ?v_97) (= x_80 (+ x_66 1))) ?v_96) ?v_98) ?v_99) (= x_91 x_90)) (= x_444 3)) (or (not (<= x_69 12)) (= x_78 x_90))) (= x_87 (store x_73 x_90 1)))) (and (and (and (and (and (= x_84 3) ?v_98) ?v_95) ?v_96) (= x_87 x_73)) ?v_99))) (= x_69 (+ x_55 1))) (= x_445 (select x_59 x_71))) (= x_446 (select x_59 x_74))) (= x_447 (select x_59 x_76))) (or (or (or (and (and (and (and (and (and (and (= x_70 0) (= x_68 (+ x_54 1))) ?v_100) ?v_101) (= x_72 x_71)) (= x_445 1)) (= x_73 (store x_59 x_71 2))) (= x_65 (store x_51 x_54 x_71))) (and (and (and (and (and (and (and (and (and (= x_70 1) ?v_102) ?v_100) ?v_101) ?v_103) ?v_104) (= x_75 x_74)) (= x_446 2)) (= x_64 x_74)) (= x_73 (store x_59 x_74 3)))) (and (and (and (and (and (and (and (and (and (= x_70 2) ?v_102) (= x_66 (+ x_52 1))) ?v_101) ?v_103) ?v_104) (= x_77 x_76)) (= x_447 3)) (or (not (<= x_55 12)) (= x_64 x_76))) (= x_73 (store x_59 x_76 1)))) (and (and (and (and (and (= x_70 3) ?v_103) ?v_100) ?v_101) (= x_73 x_59)) ?v_104))) (= x_55 (+ x_41 1))) (= x_448 (select x_45 x_57))) (= x_449 (select x_45 x_60))) (= x_450 (select x_45 x_62))) (or (or (or (and (and (and (and (and (and (and (= x_56 0) (= x_54 (+ x_40 1))) ?v_105) ?v_106) (= x_58 x_57)) (= x_448 1)) (= x_59 (store x_45 x_57 2))) (= x_51 (store x_37 x_40 x_57))) (and (and (and (and (and (and (and (and (and (= x_56 1) ?v_107) ?v_105) ?v_106) ?v_108) ?v_109) (= x_61 x_60)) (= x_449 2)) (= x_50 x_60)) (= x_59 (store x_45 x_60 3)))) (and (and (and (and (and (and (and (and (and (= x_56 2) ?v_107) (= x_52 (+ x_38 1))) ?v_106) ?v_108) ?v_109) (= x_63 x_62)) (= x_450 3)) (or (not (<= x_41 12)) (= x_50 x_62))) (= x_59 (store x_45 x_62 1)))) (and (and (and (and (and (= x_56 3) ?v_108) ?v_105) ?v_106) (= x_59 x_45)) ?v_109))) (= x_41 (+ x_27 1))) (= x_451 (select x_31 x_43))) (= x_452 (select x_31 x_46))) (= x_453 (select x_31 x_48))) (or (or (or (and (and (and (and (and (and (and (= x_42 0) (= x_40 (+ x_26 1))) ?v_110) ?v_111) (= x_44 x_43)) (= x_451 1)) (= x_45 (store x_31 x_43 2))) (= x_37 (store x_23 x_26 x_43))) (and (and (and (and (and (and (and (and (and (= x_42 1) ?v_112) ?v_110) ?v_111) ?v_113) ?v_114) (= x_47 x_46)) (= x_452 2)) (= x_36 x_46)) (= x_45 (store x_31 x_46 3)))) (and (and (and (and (and (and (and (and (and (= x_42 2) ?v_112) (= x_38 (+ x_24 1))) ?v_111) ?v_113) ?v_114) (= x_49 x_48)) (= x_453 3)) (or (not (<= x_27 12)) (= x_36 x_48))) (= x_45 (store x_31 x_48 1)))) (and (and (and (and (and (= x_42 3) ?v_113) ?v_110) ?v_111) (= x_45 x_31)) ?v_114))) (= x_27 (+ x_13 1))) (= x_454 (select x_17 x_29))) (= x_455 (select x_17 x_32))) (= x_456 (select x_17 x_34))) (or (or (or (and (and (and (and (and (and (and (= x_28 0) (= x_26 (+ x_12 1))) ?v_115) ?v_116) (= x_30 x_29)) (= x_454 1)) (= x_31 (store x_17 x_29 2))) (= x_23 (store x_9 x_12 x_29))) (and (and (and (and (and (and (and (and (and (= x_28 1) ?v_117) ?v_115) ?v_116) ?v_118) ?v_119) (= x_33 x_32)) (= x_455 2)) (= x_22 x_32)) (= x_31 (store x_17 x_32 3)))) (and (and (and (and (and (and (and (and (and (= x_28 2) ?v_117) (= x_24 (+ x_10 1))) ?v_116) ?v_118) ?v_119) (= x_35 x_34)) (= x_456 3)) (or (not (<= x_13 12)) (= x_22 x_34))) (= x_31 (store x_17 x_34 1)))) (and (and (and (and (and (= x_28 3) ?v_118) ?v_115) ?v_116) (= x_31 x_17)) ?v_119))) (= x_13 (+ x_6 1))) (= x_457 (select x_2 x_15))) (= x_458 (select x_2 x_18))) (= x_459 (select x_2 x_20))) (or (or (or (and (and (and (and (and (and (and (= x_14 0) (= x_12 (+ x_1 1))) ?v_120) ?v_121) (= x_16 x_15)) (= x_457 1)) (= x_17 (store x_2 x_15 2))) (= x_9 (store x_7 x_1 x_15))) (and (and (and (and (and (and (and (and (and (= x_14 1) ?v_122) ?v_120) ?v_121) ?v_123) ?v_124) (= x_19 x_18)) (= x_458 2)) (= x_8 x_18)) (= x_17 (store x_2 x_18 3)))) (and (and (and (and (and (and (and (and (and (= x_14 2) ?v_122) (= x_10 (+ x_0 1))) ?v_121) ?v_123) ?v_124) (= x_21 x_20)) (= x_459 3)) (or (not (<= x_6 12)) (= x_8 x_20))) (= x_17 (store x_2 x_20 1)))) (and (and (and (and (and (= x_14 3) ?v_123) ?v_120) ?v_121) (= x_17 x_2)) ?v_124))) (= x_460 (select x_353 x_3))) (= x_461 (select x_353 x_4))) (= x_462 (select x_339 x_3))) (= x_463 (select x_339 x_4))) (= x_464 (select x_325 x_3))) (= x_465 (select x_325 x_4))) (= x_466 (select x_311 x_3))) (= x_467 (select x_311 x_4))) (= x_468 (select x_297 x_3))) (= x_469 (select x_297 x_4))) (= x_470 (select x_283 x_3))) (= x_471 (select x_283 x_4))) (= x_472 (select x_269 x_3))) (= x_473 (select x_269 x_4))) (= x_474 (select x_255 x_3))) (= x_475 (select x_255 x_4))) (= x_476 (select x_241 x_3))) (= x_477 (select x_241 x_4))) (= x_478 (select x_227 x_3))) (= x_479 (select x_227 x_4))) (= x_480 (select x_213 x_3))) (= x_481 (select x_213 x_4))) (= x_482 (select x_199 x_3))) (= x_483 (select x_199 x_4))) (= x_484 (select x_185 x_3))) (= x_485 (select x_185 x_4))) (= x_486 (select x_171 x_3))) (= x_487 (select x_171 x_4))) (= x_488 (select x_157 x_3))) (= x_489 (select x_157 x_4))) (= x_490 (select x_143 x_3))) (= x_491 (select x_143 x_4))) (= x_492 (select x_129 x_3))) (= x_493 (select x_129 x_4))) (= x_494 (select x_115 x_3))) (= x_495 (select x_115 x_4))) (= x_496 (select x_101 x_3))) (= x_497 (select x_101 x_4))) (= x_498 (select x_87 x_3))) (= x_499 (select x_87 x_4))) (= x_500 (select x_73 x_3))) (= x_501 (select x_73 x_4))) (= x_502 (select x_59 x_3))) (= x_503 (select x_59 x_4))) (= x_504 (select x_45 x_3))) (= x_505 (select x_45 x_4))) (= x_506 (select x_31 x_3))) (= x_507 (select x_31 x_4))) (= x_508 (select x_17 x_3))) (= x_509 (select x_17 x_4))) (= x_510 ?v_125)) (= x_511 ?v_126)) (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (and (= x_460 3) (= x_461 3)) (and (= x_462 3) (= x_463 3))) (and (= x_464 3) (= x_465 3))) (and (= x_466 3) (= x_467 3))) (and (= x_468 3) (= x_469 3))) (and (= x_470 3) (= x_471 3))) (and (= x_472 3) (= x_473 3))) (and (= x_474 3) (= x_475 3))) (and (= x_476 3) (= x_477 3))) (and (= x_478 3) (= x_479 3))) (and (= x_480 3) (= x_481 3))) (and (= x_482 3) (= x_483 3))) (and (= x_484 3) (= x_485 3))) (and (= x_486 3) (= x_487 3))) (and (= x_488 3) (= x_489 3))) (and (= x_490 3) (= x_491 3))) (and (= x_492 3) (= x_493 3))) (and (= x_494 3) (= x_495 3))) (and (= x_496 3) (= x_497 3))) (and (= x_498 3) (= x_499 3))) (and (= x_500 3) (= x_501 3))) (and (= x_502 3) (= x_503 3))) (and (= x_504 3) (= x_505 3))) (and (= x_506 3) (= x_507 3))) (and (= x_508 3) (= x_509 3))) (and (= x_510 3) (= x_511 3)))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/boolean-terms-kernel2.smt2 b/test/regress/regress1/boolean-terms-kernel2.smt2 new file mode 100644 index 000000000..a4e49dd90 --- /dev/null +++ b/test/regress/regress1/boolean-terms-kernel2.smt2 @@ -0,0 +1,19 @@ +; COMMAND-LINE: --incremental +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_ABV) +(declare-fun b () Bool) +(declare-fun c () Bool) +(declare-fun a () (Array Bool (Array (_ BitVec 32) (_ BitVec 32)))) +(declare-fun v2 () (_ BitVec 32)) +(declare-fun r0 () (_ BitVec 32)) +(declare-fun r1 () (_ BitVec 32)) +(declare-fun l () (_ BitVec 32)) +(declare-fun i () (_ BitVec 32)) +(assert c) +(push 1) +(assert (not (=> false (not (= i (select (select a true) (bvsub (bvmul (bvsdiv v2 (_ bv2 32)) (bvadd (bvmul (_ bv2 32) l) (_ bv1 32))) (_ bv1 32)))))))) +(check-sat) +(pop 1) +(assert (not (=> (= i (select (select a true) (bvsub (bvmul (bvsdiv v2 (_ bv2 32)) (bvadd (bvmul (_ bv2 32) l) (_ bv1 32))) (_ bv1 32)))) (not (= r1 (ite b i r0)))))) +(check-sat) diff --git a/test/regress/regress1/boolean.cvc b/test/regress/regress1/boolean.cvc new file mode 100644 index 000000000..eb0e7ab52 --- /dev/null +++ b/test/regress/regress1/boolean.cvc @@ -0,0 +1,806 @@ +% EXPECT: valid +p : BOOLEAN; +q : BOOLEAN; +r : BOOLEAN; +s : BOOLEAN; +t : BOOLEAN; +u : BOOLEAN; +v : BOOLEAN; +P1 : BOOLEAN; +P2 : BOOLEAN; +P3 : BOOLEAN; +P4 : BOOLEAN; +P6 : BOOLEAN; +P5 : BOOLEAN; +a41 : BOOLEAN = + IF p THEN FALSE + ELSE TRUE + ENDIF; +a42 : BOOLEAN = + IF a41 THEN FALSE + ELSE TRUE + ENDIF; +a45 : BOOLEAN = + IF p THEN p + ELSE a41 + ENDIF; +a46 : BOOLEAN = + IF q THEN FALSE + ELSE TRUE + ENDIF; +a49 : BOOLEAN = + IF s THEN t + ELSE FALSE + ENDIF; +a58 : BOOLEAN = + IF q THEN q + ELSE a46 + ENDIF; +a59 : BOOLEAN = + IF r THEN FALSE + ELSE TRUE + ENDIF; +a61 : BOOLEAN = + IF s THEN FALSE + ELSE TRUE + ENDIF; +a62 : BOOLEAN = + IF s THEN s + ELSE a61 + ENDIF; +a65 : BOOLEAN = + IF t THEN FALSE + ELSE TRUE + ENDIF; +a67 : BOOLEAN = + IF u THEN FALSE + ELSE TRUE + ENDIF; +a73 : BOOLEAN = + IF p THEN q + ELSE FALSE + ENDIF; +a74 : BOOLEAN = + IF q THEN p + ELSE FALSE + ENDIF; +a77 : BOOLEAN = + IF r THEN TRUE + ELSE s + ENDIF; +a78 : BOOLEAN = + IF s THEN TRUE + ELSE r + ENDIF; +a81 : BOOLEAN = + IF t THEN u + ELSE a67 + ENDIF; +a82 : BOOLEAN = + IF u THEN t + ELSE a65 + ENDIF; +a88 : BOOLEAN = + IF q THEN r + ELSE FALSE + ENDIF; +a89 : BOOLEAN = + IF p THEN a88 + ELSE FALSE + ENDIF; +a92 : BOOLEAN = + IF s THEN TRUE + ELSE t + ENDIF; +a94 : BOOLEAN = + IF t THEN TRUE + ELSE u + ENDIF; +a95 : BOOLEAN = + IF s THEN TRUE + ELSE a94 + ENDIF; +a105 : BOOLEAN = + IF t THEN u + ELSE FALSE + ENDIF; +a111 : BOOLEAN = + IF p THEN q + ELSE TRUE + ENDIF; +a112 : BOOLEAN = + IF q THEN r + ELSE TRUE + ENDIF; +a114 : BOOLEAN = + IF p THEN r + ELSE TRUE + ENDIF; +a116 : BOOLEAN = + IF s THEN t + ELSE a65 + ENDIF; +a121 : BOOLEAN = + IF a46 THEN a41 + ELSE TRUE + ENDIF; +a126 : BOOLEAN = + IF a59 THEN a61 + ELSE + IF a61 THEN FALSE + ELSE TRUE + ENDIF + ENDIF; +a130 : BOOLEAN = + IF q THEN TRUE + ELSE r + ENDIF; +a132 : BOOLEAN = + IF p THEN r + ELSE FALSE + ENDIF; +a133 : BOOLEAN = + IF a73 THEN TRUE + ELSE a132 + ENDIF; +a138 : BOOLEAN = + IF a92 THEN + IF s THEN TRUE + ELSE u + ENDIF + ELSE FALSE + ENDIF; +a143 : BOOLEAN = + IF a114 THEN a112 + ELSE FALSE + ENDIF; +a145 : BOOLEAN = + IF + IF + IF p THEN TRUE + ELSE q + ENDIF THEN r + ELSE TRUE + ENDIF THEN a143 + ELSE + IF a143 THEN FALSE + ELSE TRUE + ENDIF + ENDIF; +a147 : BOOLEAN = + IF s THEN t + ELSE TRUE + ENDIF; +a148 : BOOLEAN = + IF s THEN u + ELSE TRUE + ENDIF; +a149 : BOOLEAN = + IF a147 THEN TRUE + ELSE a148 + ENDIF; +a153 : BOOLEAN = + IF a73 THEN r + ELSE TRUE + ENDIF; +a154 : BOOLEAN = + IF a114 THEN TRUE + ELSE a112 + ENDIF; +a158 : BOOLEAN = + IF a147 THEN a148 + ELSE FALSE + ENDIF; +a162 : BOOLEAN = + IF p THEN a112 + ELSE TRUE + ENDIF; +a167 : BOOLEAN = + IF a46 THEN TRUE + ELSE a59 + ENDIF; +a171 : BOOLEAN = + IF a61 THEN a65 + ELSE FALSE + ENDIF; +a176 : BOOLEAN = + IF p THEN q + ELSE r + ENDIF; +a178 : BOOLEAN = + IF p THEN a46 + ELSE a59 + ENDIF; +a183 : BOOLEAN = + IF s THEN a65 + ELSE + IF a65 THEN FALSE + ELSE TRUE + ENDIF + ENDIF; +a187 : BOOLEAN = + IF a41 THEN TRUE + ELSE q + ENDIF; +a192 : BOOLEAN = + IF + IF r THEN s + ELSE FALSE + ENDIF THEN TRUE + ELSE + IF a59 THEN t + ELSE FALSE + ENDIF + ENDIF; +a197 : BOOLEAN = + IF a111 THEN + IF a41 THEN r + ELSE TRUE + ENDIF + ELSE FALSE + ENDIF; +a200 : BOOLEAN = + IF a49 THEN TRUE + ELSE a171 + ENDIF; +a204 : BOOLEAN = + IF p THEN q + ELSE a46 + ENDIF; +a205 : BOOLEAN = + IF q THEN p + ELSE TRUE + ENDIF; +a206 : BOOLEAN = + IF a111 THEN a205 + ELSE FALSE + ENDIF; +a210 : BOOLEAN = + IF p THEN a46 + ELSE TRUE + ENDIF; +a214 : BOOLEAN = + IF a73 THEN FALSE + ELSE TRUE + ENDIF; +a221 : BOOLEAN = + IF + IF p THEN a46 + ELSE FALSE + ENDIF THEN r + ELSE TRUE + ENDIF; +a225 : BOOLEAN = + IF a187 THEN a132 + ELSE TRUE + ENDIF; +a228 : BOOLEAN = + IF q THEN r + ELSE a59 + ENDIF; +a231 : BOOLEAN = + IF a204 THEN r + ELSE a59 + ENDIF; +a237 : BOOLEAN = + IF q THEN a132 + ELSE + IF a41 THEN s + ELSE FALSE + ENDIF + ENDIF; +a288 : BOOLEAN = + IF + IF + IF p THEN a41 + ELSE a42 + ENDIF THEN FALSE + ELSE TRUE + ENDIF THEN + IF + IF a45 THEN + IF + IF q THEN TRUE + ELSE a46 + ENDIF THEN + IF + IF r THEN r + ELSE TRUE + ENDIF THEN + IF + IF a49 THEN s + ELSE TRUE + ENDIF THEN + IF u THEN + IF u THEN TRUE + ELSE v + ENDIF + ELSE TRUE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF a58 THEN + IF + IF r THEN r + ELSE a59 + ENDIF THEN a62 + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF a45 THEN + IF a62 THEN + IF + IF t THEN t + ELSE a65 + ENDIF THEN + IF a67 THEN a67 + ELSE + IF a67 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF a73 THEN a74 + ELSE + IF a74 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF a77 THEN a78 + ELSE + IF a78 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF a81 THEN a82 + ELSE + IF a82 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF + IF a73 THEN r + ELSE FALSE + ENDIF THEN a89 + ELSE + IF a89 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF a92 THEN TRUE + ELSE u + ENDIF THEN a95 + ELSE + IF a95 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF + IF p THEN p + ELSE FALSE + ENDIF THEN p + ELSE a41 + ENDIF THEN + IF + IF + IF q THEN TRUE + ELSE q + ENDIF THEN q + ELSE a46 + ENDIF THEN + IF + IF + IF r THEN a77 + ELSE FALSE + ENDIF THEN r + ELSE a59 + ENDIF THEN + IF + IF t THEN TRUE + ELSE a105 + ENDIF THEN t + ELSE a65 + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF THEN + IF a58 THEN + IF + IF + IF + IF a111 THEN a112 + ELSE FALSE + ENDIF THEN a114 + ELSE TRUE + ENDIF THEN + IF + IF a116 THEN a81 + ELSE FALSE + ENDIF THEN + IF s THEN u + ELSE a67 + ENDIF + ELSE TRUE + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF a111 THEN a121 + ELSE + IF a121 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF r THEN s + ELSE a61 + ENDIF THEN a126 + ELSE + IF a126 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF + IF p THEN a130 + ELSE FALSE + ENDIF THEN a133 + ELSE + IF a133 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF s THEN TRUE + ELSE a105 + ENDIF THEN a138 + ELSE + IF a138 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF a145 THEN + IF + IF s THEN a94 + ELSE TRUE + ENDIF THEN a149 + ELSE + IF a149 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF a153 THEN a154 + ELSE + IF a154 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF s THEN a105 + ELSE TRUE + ENDIF THEN a158 + ELSE + IF a158 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF a153 THEN a162 + ELSE + IF a162 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF + IF a42 THEN p + ELSE a41 + ENDIF THEN + IF + IF + IF a88 THEN FALSE + ELSE TRUE + ENDIF THEN a167 + ELSE + IF a167 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF a92 THEN FALSE + ELSE TRUE + ENDIF THEN a171 + ELSE + IF a171 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF + IF a176 THEN FALSE + ELSE TRUE + ENDIF THEN a178 + ELSE + IF a178 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF a116 THEN FALSE + ELSE TRUE + ENDIF THEN a183 + ELSE + IF a183 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF a111 THEN a187 + ELSE + IF a187 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF r THEN s + ELSE t + ENDIF THEN a192 + ELSE + IF a192 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF + IF a176 THEN a197 + ELSE + IF a197 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF a116 THEN a200 + ELSE + IF a200 THEN FALSE + ELSE TRUE + ENDIF + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF a204 THEN a206 + ELSE + IF a206 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF a111 THEN TRUE + ELSE a205 + ENDIF THEN + IF + IF a46 THEN TRUE + ELSE + IF + IF a210 THEN p + ELSE FALSE + ENDIF THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF a210 THEN a214 + ELSE + IF a214 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF a145 THEN + IF + IF a162 THEN a153 + ELSE + IF a153 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF + IF p THEN a130 + ELSE TRUE + ENDIF THEN a221 + ELSE + IF a221 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF + IF p THEN a112 + ELSE FALSE + ENDIF THEN a225 + ELSE + IF a225 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF + IF p THEN a228 + ELSE + IF a228 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN a231 + ELSE + IF a231 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF + IF p THEN a88 + ELSE + IF a46 THEN s + ELSE FALSE + ENDIF + ENDIF THEN a237 + ELSE + IF a237 THEN FALSE + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF + IF P1 THEN + IF P2 THEN TRUE + ELSE P3 + ENDIF + ELSE + IF P3 THEN TRUE + ELSE P4 + ENDIF + ENDIF THEN + IF + IF P3 THEN + IF P6 THEN FALSE + ELSE TRUE + ENDIF + ELSE + IF P4 THEN P1 + ELSE TRUE + ENDIF + ENDIF THEN + IF + IF + IF P2 THEN P5 + ELSE FALSE + ENDIF THEN FALSE + ELSE TRUE + ENDIF THEN + IF P2 THEN P5 + ELSE TRUE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF THEN + IF + IF P3 THEN P6 + ELSE TRUE + ENDIF THEN FALSE + ELSE TRUE + ENDIF + ELSE TRUE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF + ELSE FALSE + ENDIF; +QUERY a288; diff --git a/test/regress/regress1/bug216.smt2 b/test/regress/regress1/bug216.smt2 new file mode 100644 index 000000000..78e0f716c --- /dev/null +++ b/test/regress/regress1/bug216.smt2 @@ -0,0 +1,8 @@ +(set-logic QF_UF) +(declare-fun x () Bool) +(declare-fun y () Bool) +(assert (=> x y)) +(check-sat) ; returns sat +(assert (=> y x)) +(assert (and x (not y))) +(check-sat) ; returns sat --> ERROR diff --git a/test/regress/regress1/bug216.smt2.expect b/test/regress/regress1/bug216.smt2.expect new file mode 100644 index 000000000..fe118171a --- /dev/null +++ b/test/regress/regress1/bug216.smt2.expect @@ -0,0 +1,3 @@ +% COMMAND-LINE: --incremental +% EXPECT: sat +% EXPECT: unsat diff --git a/test/regress/regress1/bug296.smt2 b/test/regress/regress1/bug296.smt2 new file mode 100644 index 000000000..3aea7e9c9 --- /dev/null +++ b/test/regress/regress1/bug296.smt2 @@ -0,0 +1,1698 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: unsat +(set-logic QF_ALL) +(set-info :status unsat) +(declare-datatypes + () ( + (MsgResult (MsgResult_MsgOK (destMsgResult_MsgOK Real)) + (MsgResult_MsgAudit (destMsgResult_MsgAudit Real))) + (MsgTree (MsgTree_Leaf) + (MsgTree_Node (destMsgTree_Node MsgTree_Node_recd))) + (TreeResult (TreeResult_TreeOK (destTreeResult_TreeOK MsgTree)) + (TreeResult_TreeAudit (destTreeResult_TreeAudit Real))) + (MsgTree_Node_recd + (MsgTree_Node_recd (MsgTree_Node_recd_Value Real) + (MsgTree_Node_recd_Left MsgTree) + (MsgTree_Node_recd_Right MsgTree))))) +(declare-fun Guardfn (MsgTree) TreeResult) +(declare-fun Input () MsgTree) +(declare-fun M () Real) +(declare-fun f (Real) MsgResult) +(declare-fun n () MsgTree_Node_recd) +(declare-fun ARB () Bool) +(declare-fun Guard_Checkfn (MsgTree) Bool) +(define-fun DWS_Idempotentfn ((M1 Real)) Bool + (ite (is-MsgResult_MsgOK (f M1)) + (and (is-MsgResult_MsgOK (f (destMsgResult_MsgOK (f M1)))) + (= (destMsgResult_MsgOK (f M1)) + (destMsgResult_MsgOK (f (destMsgResult_MsgOK (f M1)))))) + (or (is-MsgResult_MsgAudit (f M1)) ARB))) +(assert + (and + (=> + (and (not (is-MsgTree_Leaf Input)) + (and (is-MsgTree_Node Input) + (and + (not + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value (destMsgTree_Node Input))))) + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value (destMsgTree_Node Input)))) + (and + (not + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))) + (and + (is-TreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (is-TreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))) + (Guard_Checkfn + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input)))))) + (and + (=> + (and (not (is-MsgTree_Leaf Input)) + (and (is-MsgTree_Node Input) + (and + (not + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (is-TreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))))))) + (Guard_Checkfn + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))))) + (and + (DWS_Idempotentfn + (MsgTree_Node_recd_Value (destMsgTree_Node Input))) + (and + (is-TreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))) + (not + (Guard_Checkfn + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))))) +(assert + (= + (Guard_Checkfn + (destTreeResult_TreeOK + (Guardfn (MsgTree_Node_recd_Right (destMsgTree_Node Input))))) + (ite + (is-MsgTree_Leaf + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))) +(assert + (= + (Guard_Checkfn + (destTreeResult_TreeOK + (Guardfn (MsgTree_Node_recd_Left (destMsgTree_Node Input))))) + (ite + (is-MsgTree_Leaf + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))))))) +(assert + (= + (Guard_Checkfn + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f (MsgTree_Node_recd_Value (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))) + (ite + (is-MsgTree_Leaf + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))))))) +(assert + (= + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input))))))) + (ite + (is-MsgTree_Leaf + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input))))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))) +(assert + (= + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input))))))) + (ite + (is-MsgTree_Leaf + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input))))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))) +(assert + (= + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))))))) + (ite + (is-MsgTree_Leaf + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))))))))) +(assert + (= + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))))))) + (ite + (is-MsgTree_Leaf + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))))))))))))))) +(assert + (= + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))) + (ite + (is-MsgTree_Leaf + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))))))))) +(assert + (= + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))) + (ite + (is-MsgTree_Leaf + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))) + true + (and + (is-MsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))))))) + (and + (= + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))))) + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))))) + (and + (Guard_Checkfn + (MsgTree_Node_recd_Left + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))) + (Guard_Checkfn + (MsgTree_Node_recd_Right + (destMsgTree_Node + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))))))))))))))))))))))) +(assert + (not + (not + (is-MsgTree_Leaf + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input)))))))))) +(assert + (not + (not + (is-MsgTree_Leaf + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right (destMsgTree_Node Input)))))))))) +(assert + (not + (not + (is-MsgTree_Leaf + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))))))))) +(assert + (not + (not + (is-MsgTree_Leaf + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left (destMsgTree_Node Input)))))))))) +(assert + (not + (not + (is-MsgTree_Leaf + (MsgTree_Node_recd_Left + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))))))) +(assert + (not + (not + (is-MsgTree_Leaf + (MsgTree_Node_recd_Right + (destMsgTree_Node + (destTreeResult_TreeOK + (ite (is-MsgTree_Leaf Input) + (TreeResult_TreeOK MsgTree_Leaf) + (ite + (is-MsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (TreeResult_TreeAudit + (destMsgResult_MsgAudit + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input))))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input))) + (ite + (is-TreeResult_TreeAudit + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))) + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input))) + (TreeResult_TreeOK + (MsgTree_Node + (MsgTree_Node_recd + (destMsgResult_MsgOK + (f + (MsgTree_Node_recd_Value + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Left + (destMsgTree_Node Input)))) + (destTreeResult_TreeOK + (Guardfn + (MsgTree_Node_recd_Right + (destMsgTree_Node Input)))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/bug472.smt2 b/test/regress/regress1/bug472.smt2 new file mode 100644 index 000000000..7af988ec3 --- /dev/null +++ b/test/regress/regress1/bug472.smt2 @@ -0,0 +1,8 @@ +(set-logic QF_AUFLIA) +(set-option :produce-models true) +(declare-fun a () (Array Int Int)) +(assert (= (select a 0) 0)) +(check-sat) +(get-value (a)) +(assert (= a @1)) +(check-sat) diff --git a/test/regress/regress1/bug507.smt2 b/test/regress/regress1/bug507.smt2 new file mode 100644 index 000000000..a20dddfe7 --- /dev/null +++ b/test/regress/regress1/bug507.smt2 @@ -0,0 +1,80 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Datatype declarations +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(declare-datatypes () + ((ColorType (ColorType_Red) (ColorType_Black)) +)) + +(declare-datatypes () + ((RBTree (RBTree_Leaf) (RBTree_Node (destRBTree_Node RBTree_Node_recd))) + + (RBTree_Node_recd (RBTree_Node_recd (RBTree_Node_recd_color ColorType) + (RBTree_Node_recd_left RBTree) (RBTree_Node_recd_elem Int) + (RBTree_Node_recd_right RBTree))) +)) + +(declare-datatypes () + ((BoolColor (BoolColor (BoolColor_res Bool) (BoolColor_color ColorType))) +)) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Uninterpreted symbols +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(declare-fun v0 () Int) +(declare-fun t () RBTree) +;; (declare-fun NoTwoRedsFn (RBTree) BoolColor) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Defined symbols +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(define-fun assembleFn ((ll RBTree) (le Int) (lr RBTree) (e Int) (rl RBTree) (re Int) (rr RBTree)) RBTree + (RBTree_Node (RBTree_Node_recd ColorType_Red (RBTree_Node (RBTree_Node_recd ColorType_Black ll le lr)) e (RBTree_Node (RBTree_Node_recd ColorType_Black rl re rr))))) + +(define-fun balanceFn ((c ColorType) (left RBTree) (elem Int) (right RBTree)) RBTree + (ite (= c ColorType_Black) (ite (not (ite (is-RBTree_Leaf left) false (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) true false)) true))) (ite (is-RBTree_Leaf right) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node right))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node right)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node right))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node right))) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node right)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) ColorType_Red)) (assembleFn left elem (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_elem (destRBTree_Node right)) (RBTree_Node_recd_right (destRBTree_Node right))) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node right)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node right)))) ColorType_Red)) (assembleFn left elem (RBTree_Node_recd_left (destRBTree_Node right)) (RBTree_Node_recd_elem (destRBTree_Node right)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node right)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node right)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node right))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node right))) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node right)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) ColorType_Red)) (assembleFn left elem (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_elem (destRBTree_Node right)) (RBTree_Node_recd_right (destRBTree_Node right))) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node right))) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node right)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) ColorType_Red)) (assembleFn left elem (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node right)))) (RBTree_Node_recd_elem (destRBTree_Node right)) (RBTree_Node_recd_right (destRBTree_Node right))) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))))))) (ite (is-RBTree_Leaf left) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (not (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) false (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) true false))) (ite (is-RBTree_Leaf (RBTree_Node_recd_right (destRBTree_Node left))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node left)) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_right (destRBTree_Node left)))) elem right) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)))))) (ite (is-RBTree_Leaf (RBTree_Node_recd_left (destRBTree_Node left))) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right)) (ite (and (= (RBTree_Node_recd_color (destRBTree_Node left)) ColorType_Red) (= (RBTree_Node_recd_color (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) ColorType_Red)) (assembleFn (RBTree_Node_recd_left (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_right (destRBTree_Node (RBTree_Node_recd_left (destRBTree_Node left)))) (RBTree_Node_recd_elem (destRBTree_Node left)) (RBTree_Node_recd_right (destRBTree_Node left)) elem right) (RBTree_Node (RBTree_Node_recd ColorType_Black left elem right))))))) (RBTree_Node (RBTree_Node_recd c left elem right)))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Catamorphisms +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +( declare-fun memberFn ( Int RBTree ) Bool ) + +( declare-fun EqualBlackPathsFn ( RBTree ) Int ) + +( declare-fun insFn ( Int RBTree ) RBTree ) + +( declare-fun insertFn ( Int RBTree ) RBTree ) + +( declare-fun NoTwoRedsFn ( RBTree ) BoolColor ) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Goals +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + +;;(push) +(assert (and (is-RBTree_Leaf t) + (and (not (is-RBTree_Leaf (insertFn v0 t))) + (not (BoolColor_res (NoTwoRedsFn (RBTree_Node_recd_left (destRBTree_Node (insertFn v0 t))))))))) + +;;(pop) + +( assert ( = ( insertFn v0 t ) ( ite ( is-RBTree_Leaf ( insFn v0 t ) ) ( insFn v0 t ) ( RBTree_Node ( RBTree_Node_recd ColorType_Black ( RBTree_Node_recd_left ( destRBTree_Node ( insFn v0 t ) ) ) ( RBTree_Node_recd_elem ( destRBTree_Node ( insFn v0 t ) ) ) ( RBTree_Node_recd_right ( destRBTree_Node ( insFn v0 t ) ) ) ) ) ) ) ) +( assert ( = ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ( ite ( is-RBTree_Leaf ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ( BoolColor true ColorType_Black ) ( BoolColor ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ( or ( not ( = ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ColorType_Red ) ) ( and ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ColorType_Red ) ) ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ColorType_Red ) ) ) ) ) ) ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ) ) +( assert ( = ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ( ite ( is-RBTree_Leaf ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ( BoolColor true ColorType_Black ) ( BoolColor ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ( or ( not ( = ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ColorType_Red ) ) ( and ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ColorType_Red ) ) ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ColorType_Red ) ) ) ) ) ) ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 t ) ) ) ) ) ) ) ) ) +( assert ( = ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ( ite ( is-RBTree_Leaf ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ( BoolColor true ColorType_Black ) ( BoolColor ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ( or ( not ( = ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ColorType_Red ) ) ( and ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ColorType_Red ) ) ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ColorType_Red ) ) ) ) ) ) ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ) ) +( assert ( = ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ( ite ( is-RBTree_Leaf ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ( BoolColor true ColorType_Black ) ( BoolColor ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ( or ( not ( = ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ColorType_Red ) ) ( and ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ColorType_Red ) ) ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ColorType_Red ) ) ) ) ) ) ( RBTree_Node_recd_color ( destRBTree_Node ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ) ) +( assert ( = ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ( ite ( is-RBTree_Leaf ( insFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ( insFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ( RBTree_Node ( RBTree_Node_recd ColorType_Black ( RBTree_Node_recd_left ( destRBTree_Node ( insFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ( RBTree_Node_recd_elem ( destRBTree_Node ( insFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ( RBTree_Node_recd_right ( destRBTree_Node ( insFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ) ) ) ) +( assert ( = ( NoTwoRedsFn ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ( ite ( is-RBTree_Leaf ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ( BoolColor true ColorType_Black ) ( BoolColor ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ) ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ) ( or ( not ( = ( RBTree_Node_recd_color ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ColorType_Red ) ) ( and ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ) ColorType_Red ) ) ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ) ColorType_Red ) ) ) ) ) ) ( RBTree_Node_recd_color ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_right ( destRBTree_Node t ) ) ) ) ) ) ) ) ) +( assert ( = ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ( ite ( is-RBTree_Leaf ( insFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ( insFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ( RBTree_Node ( RBTree_Node_recd ColorType_Black ( RBTree_Node_recd_left ( destRBTree_Node ( insFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ( RBTree_Node_recd_elem ( destRBTree_Node ( insFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ( RBTree_Node_recd_right ( destRBTree_Node ( insFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ) ) ) ) +( assert ( = ( NoTwoRedsFn ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ( ite ( is-RBTree_Leaf ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ( BoolColor true ColorType_Black ) ( BoolColor ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ) ( and ( BoolColor_res ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ) ( or ( not ( = ( RBTree_Node_recd_color ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ColorType_Red ) ) ( and ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_left ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ) ColorType_Red ) ) ( not ( = ( BoolColor_color ( NoTwoRedsFn ( RBTree_Node_recd_right ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ) ColorType_Red ) ) ) ) ) ) ( RBTree_Node_recd_color ( destRBTree_Node ( insertFn v0 ( RBTree_Node_recd_left ( destRBTree_Node t ) ) ) ) ) ) ) ) ) +( check-sat ) diff --git a/test/regress/regress1/bug512.smt2 b/test/regress/regress1/bug512.smt2 new file mode 100644 index 000000000..1c8a0626a --- /dev/null +++ b/test/regress/regress1/bug512.smt2 @@ -0,0 +1,146 @@ +; COMMAND-LINE: --tlimit-per 2500 -iq +; EXPECT: unknown +; EXPECT: (:reason-unknown incomplete) +; EXPECT: unsat +(set-option :print-success false) +(set-info :smt-lib-version 2.0) +;(set-option :AUTO_CONFIG false) +;(set-option :MODEL_HIDE_UNUSED_PARTITIONS false) +;(set-option :MODEL_V2 true) +;(set-option :ASYNC_COMMANDS false) +;(set-option :PHASE_SELECTION 0) +;(set-option :RESTART_STRATEGY 0) +;(set-option :RESTART_FACTOR |1.5|) +;(set-option :ARITH_RANDOM_INITIAL_VALUE true) +;(set-option :CASE_SPLIT 3) +;(set-option :DELAY_UNITS true) +;(set-option :DELAY_UNITS_THRESHOLD 16) +;(set-option :NNF_SK_HACK true) +;(set-option :MBQI false) +;(set-option :QI_EAGER_THRESHOLD 100) +;(set-option :QI_COST |"(+ weight generation)"|) +;(set-option :TYPE_CHECK true) +;(set-option :BV_REFLECT true) +; done setting options + +; Boogie universal background predicate +; Copyright (c) 2004-2010, Microsoft Corp. +(set-info :category "industrial") +(declare-sort |T@U| 0) +(declare-sort |T@T| 0) +(declare-fun real_pow (Real Real) Real) +(declare-fun UOrdering2 (|T@U| |T@U|) Bool) +(declare-fun UOrdering3 (|T@T| |T@U| |T@U|) Bool) + +(declare-fun tickleBool (Bool) Bool) +(assert (and (tickleBool true) (tickleBool false))) +(declare-fun Ctor (T@T) Int) +(declare-fun intType () T@T) +(declare-fun realType () T@T) +(declare-fun boolType () T@T) +(declare-fun int_2_U (Int) T@U) +(declare-fun U_2_int (T@U) Int) +(declare-fun type (T@U) T@T) +(declare-fun real_2_U (Real) T@U) +(declare-fun U_2_real (T@U) Real) +(declare-fun bool_2_U (Bool) T@U) +(declare-fun U_2_bool (T@U) Bool) +(declare-fun %lbl%+67 () Bool) +(declare-fun i@0 () Int) +(declare-fun x@@5 () Int) +(declare-fun y@@1 () Int) +(declare-fun i@1 () Int) +(declare-fun %lbl%@186 () Bool) +(declare-fun %lbl%+69 () Bool) +(declare-fun %lbl%@157 () Bool) +(declare-fun %lbl%+65 () Bool) +(declare-fun %lbl%+63 () Bool) +(declare-fun %lbl%@125 () Bool) +(declare-fun %lbl%+97 () Bool) +(assert (and +(= (Ctor intType) 0) +(= (Ctor realType) 1) +(= (Ctor boolType) 2) +(forall ((arg0 Int) ) (! (= (U_2_int (int_2_U arg0)) arg0) + :qid |typeInv:U_2_int| + :pattern ( (int_2_U arg0)) +)) +(forall ((x T@U) ) (! (=> (= (type x) intType) (= (int_2_U (U_2_int x)) x)) + :qid |cast:U_2_int| + :pattern ( (U_2_int x)) +)) +(forall ((arg0@@0 Int) ) (! (= (type (int_2_U arg0@@0)) intType) + :qid |funType:int_2_U| + :pattern ( (int_2_U arg0@@0)) +)) +(forall ((arg0@@1 Real) ) (! (= (U_2_real (real_2_U arg0@@1)) arg0@@1) + :qid |typeInv:U_2_real| + :pattern ( (real_2_U arg0@@1)) +)) +(forall ((x@@0 T@U) ) (! (=> (= (type x@@0) realType) (= (real_2_U (U_2_real x@@0)) x@@0)) + :qid |cast:U_2_real| + :pattern ( (U_2_real x@@0)) +)) +(forall ((arg0@@2 Real) ) (! (= (type (real_2_U arg0@@2)) realType) + :qid |funType:real_2_U| + :pattern ( (real_2_U arg0@@2)) +)) +(forall ((arg0@@3 Bool) ) (! (= (U_2_bool (bool_2_U arg0@@3)) arg0@@3) + :qid |typeInv:U_2_bool| + :pattern ( (bool_2_U arg0@@3)) +)) +(forall ((x@@1 T@U) ) (! (=> (= (type x@@1) boolType) (= (bool_2_U (U_2_bool x@@1)) x@@1)) + :qid |cast:U_2_bool| + :pattern ( (U_2_bool x@@1)) +)) +(forall ((arg0@@4 Bool) ) (! (= (type (bool_2_U arg0@@4)) boolType) + :qid |funType:bool_2_U| + :pattern ( (bool_2_U arg0@@4)) +)))) +(assert (forall ((x@@2 T@U) ) (! (UOrdering2 x@@2 x@@2) + :qid |bg:subtype-refl| + :no-pattern (U_2_int x@@2) + :no-pattern (U_2_bool x@@2) +))) +(assert (forall ((x@@3 T@U) (y T@U) (z T@U) ) (! (let ((alpha (type x@@3))) +(=> (and +(= (type y) alpha) +(= (type z) alpha) +(UOrdering2 x@@3 y) +(UOrdering2 y z)) (UOrdering2 x@@3 z))) + :qid |bg:subtype-trans| + :pattern ( (UOrdering2 x@@3 y) (UOrdering2 y z)) +))) +(assert (forall ((x@@4 T@U) (y@@0 T@U) ) (! (let ((alpha@@0 (type x@@4))) +(=> (= (type y@@0) alpha@@0) (=> (and +(UOrdering2 x@@4 y@@0) +(UOrdering2 y@@0 x@@4)) (= x@@4 y@@0)))) + :qid |bg:subtype-antisymm| + :pattern ( (UOrdering2 x@@4 y@@0) (UOrdering2 y@@0 x@@4)) +))) +(push 1) +(set-info :boogie-vc-id foo) +(assert (not +(let ((anon3_LoopBody_correct (=> (! (and %lbl%+67 true) :lblpos +67) (=> (and +(< i@0 (+ x@@5 y@@1)) +(= i@1 (+ i@0 1))) (and +(! (or %lbl%@186 (<= i@1 (+ x@@5 y@@1))) :lblneg @186) +(=> (<= i@1 (+ x@@5 y@@1)) true)))))) +(let ((anon3_LoopDone_correct (=> (! (and %lbl%+69 true) :lblpos +69) (=> (<= (+ x@@5 y@@1) i@0) (and +(! (or %lbl%@157 (= i@0 (- x@@5 y@@1))) :lblneg @157) +(=> (= i@0 (- x@@5 y@@1)) true)))))) +(let ((anon3_LoopHead_correct (=> (! (and %lbl%+65 true) :lblpos +65) (=> (<= i@0 (+ x@@5 y@@1)) (and +anon3_LoopDone_correct +anon3_LoopBody_correct))))) +(let ((anon0_correct (=> (! (and %lbl%+63 true) :lblpos +63) (and +(! (or %lbl%@125 (<= x@@5 (+ x@@5 y@@1))) :lblneg @125) +(=> (<= x@@5 (+ x@@5 y@@1)) anon3_LoopHead_correct))))) +(let ((PreconditionGeneratedEntry_correct (=> (! (and %lbl%+97 true) :lblpos +97) (=> (>= y@@1 0) anon0_correct)))) +PreconditionGeneratedEntry_correct))))) +)) +(check-sat) +(get-info :reason-unknown) +;(labels) +(assert %lbl%@157) +(check-sat) +(pop 1) diff --git a/test/regress/regress1/bug516.smt2 b/test/regress/regress1/bug516.smt2 new file mode 100644 index 000000000..a01eb97e9 --- /dev/null +++ b/test/regress/regress1/bug516.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --finite-model-find --fmf-bound-int +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(set-option :incremental true) +(declare-fun P (Int) Bool) +(declare-fun ten () Int) + +(assert (forall ((x Int)) (=> (<= 1 x ten) (P x)))) + +(push) +(assert (= ten 10)) + +(check-sat) +(pop) diff --git a/test/regress/regress1/bug520.smt2 b/test/regress/regress1/bug520.smt2 new file mode 100644 index 000000000..4bdb968d8 --- /dev/null +++ b/test/regress/regress1/bug520.smt2 @@ -0,0 +1,173 @@ +; Automatically generated by SBV. Do not edit. +(set-option :produce-models true) +(set-logic QF_UFBV) +(set-info :status sat) +; --- uninterpreted sorts --- +; --- literal constants --- +(define-fun s_2 () Bool false) +(define-fun s_1 () Bool true) +(define-fun s77 () (_ BitVec 8) #x00) +(define-fun s78 () (_ BitVec 8) #x04) +(define-fun s81 () (_ BitVec 8) #x01) +(define-fun s83 () (_ BitVec 8) #xff) +; --- skolem constants --- +(declare-fun s0 () (_ BitVec 8)) +(declare-fun s1 () (_ BitVec 8)) +(declare-fun s2 () (_ BitVec 8)) +(declare-fun s3 () Bool) +(declare-fun s4 () (_ BitVec 8)) +(declare-fun s5 () Bool) +(declare-fun s6 () (_ BitVec 8)) +(declare-fun s7 () Bool) +(declare-fun s8 () (_ BitVec 8)) +(declare-fun s9 () Bool) +(declare-fun s10 () (_ BitVec 8)) +(declare-fun s11 () Bool) +(declare-fun s12 () (_ BitVec 8)) +(declare-fun s13 () Bool) +(declare-fun s14 () (_ BitVec 8)) +(declare-fun s15 () Bool) +(declare-fun s16 () (_ BitVec 8)) +(declare-fun s17 () Bool) +(declare-fun s18 () (_ BitVec 8)) +(declare-fun s19 () Bool) +(declare-fun s20 () (_ BitVec 8)) +(declare-fun s21 () Bool) +(declare-fun s22 () (_ BitVec 8)) +(declare-fun s23 () Bool) +(declare-fun s24 () (_ BitVec 8)) +(declare-fun s25 () Bool) +(declare-fun s26 () (_ BitVec 8)) +(declare-fun s27 () Bool) +(declare-fun s28 () (_ BitVec 8)) +(declare-fun s29 () Bool) +(declare-fun s30 () (_ BitVec 8)) +(declare-fun s31 () Bool) +(declare-fun s32 () (_ BitVec 8)) +(declare-fun s33 () Bool) +(declare-fun s34 () (_ BitVec 8)) +(declare-fun s35 () Bool) +(declare-fun s36 () (_ BitVec 8)) +(declare-fun s37 () Bool) +(declare-fun s38 () (_ BitVec 8)) +(declare-fun s39 () Bool) +(declare-fun s40 () (_ BitVec 8)) +(declare-fun s41 () Bool) +(declare-fun s42 () (_ BitVec 8)) +; --- constant tables --- +; --- skolemized tables --- +(declare-fun table0 ((_ BitVec 8)) (_ BitVec 8)) +(declare-fun table1 ((_ BitVec 8)) Bool) +(declare-fun table2 ((_ BitVec 8)) (_ BitVec 8)) +(declare-fun table3 ((_ BitVec 8)) Bool) +; --- arrays --- +; --- uninterpreted constants --- +; --- user given axioms --- +; --- formula --- +(assert ; no quantifiers + (let ((s43 (and s3 s5))) + (let ((s44 (or s3 s5))) + (let ((s45 (not s44))) + (let ((s46 (= (bvcomp s4 s6) #b1))) + (let ((s47 (and s45 s46))) + (let ((s48 (or s43 s47))) + (let ((s49 (and s11 s13))) + (let ((s50 (or s11 s13))) + (let ((s51 (not s50))) + (let ((s52 (= (bvcomp s12 s14) #b1))) + (let ((s53 (and s51 s52))) + (let ((s54 (or s49 s53))) + (let ((s55 (and s19 s21))) + (let ((s56 (or s19 s21))) + (let ((s57 (not s56))) + (let ((s58 (= (bvcomp s20 s22) #b1))) + (let ((s59 (and s57 s58))) + (let ((s60 (or s55 s59))) + (let ((s61 (and s27 s29))) + (let ((s62 (or s27 s29))) + (let ((s63 (not s62))) + (let ((s64 (= (bvcomp s28 s30) #b1))) + (let ((s65 (and s63 s64))) + (let ((s66 (or s61 s65))) + (let ((s67 (and s35 s37))) + (let ((s68 (or s35 s37))) + (let ((s69 (not s68))) + (let ((s70 (= (bvcomp s36 s38) #b1))) + (let ((s71 (and s69 s70))) + (let ((s72 (or s67 s71))) + (let ((s73 (and s66 s72))) + (let ((s74 (and s60 s73))) + (let ((s75 (and s54 s74))) + (let ((s76 (and s48 s75))) + (let ((s79 (bvurem s0 s78))) + (let ((s80 (not (= (bvcomp s77 s79) #b1)))) + (let ((s82 (ite s80 s81 s77))) + (let ((s84 (= (bvcomp s82 s83) #b1))) + (let ((s85 (bvadd s78 s79))) + (let ((s86 (ite s84 s85 s79))) + (let ((s87 (ite (bvule #x04 s86) s77 (table0 s86)))) + (let ((s88 (= (bvcomp s8 s87) #b1))) + (let ((s89 (ite (bvule #x04 s86) s_2 (table1 s86)))) + (let ((s90 (= s7 s89))) + (let ((s91 (ite (bvule #x04 s86) s77 (table2 s86)))) + (let ((s92 (= (bvcomp s10 s91) #b1))) + (let ((s93 (ite (bvule #x04 s86) s_2 (table3 s86)))) + (let ((s94 (= s9 s93))) + (let ((s95 (and s92 s94))) + (let ((s96 (and s90 s95))) + (let ((s97 (and s88 s96))) + (let ((s98 (and s7 s9))) + (let ((s99 (or s7 s9))) + (let ((s100 (not s99))) + (let ((s101 (= (bvcomp s8 s10) #b1))) + (let ((s102 (and s100 s101))) + (let ((s103 (or s98 s102))) + (let ((s104 (and s15 s17))) + (let ((s105 (or s15 s17))) + (let ((s106 (not s105))) + (let ((s107 (= (bvcomp s16 s18) #b1))) + (let ((s108 (and s106 s107))) + (let ((s109 (or s104 s108))) + (let ((s110 (and s23 s25))) + (let ((s111 (or s23 s25))) + (let ((s112 (not s111))) + (let ((s113 (= (bvcomp s24 s26) #b1))) + (let ((s114 (and s112 s113))) + (let ((s115 (or s110 s114))) + (let ((s116 (and s31 s33))) + (let ((s117 (or s31 s33))) + (let ((s118 (not s117))) + (let ((s119 (= (bvcomp s32 s34) #b1))) + (let ((s120 (and s118 s119))) + (let ((s121 (or s116 s120))) + (let ((s122 (and s39 s41))) + (let ((s123 (or s39 s41))) + (let ((s124 (not s123))) + (let ((s125 (= (bvcomp s40 s42) #b1))) + (let ((s126 (and s124 s125))) + (let ((s127 (or s122 s126))) + (let ((s128 (and s121 s127))) + (let ((s129 (and s115 s128))) + (let ((s130 (and s109 s129))) + (let ((s131 (and s103 s130))) + (let ((s132 (not s131))) + (let ((s133 (and s97 s132))) + (let ((s134 (and s76 s133))) + (and (= (table0 #x00) s12) + (= (table0 #x01) s20) + (= (table0 #x02) s28) + (= (table0 #x03) s36) + (= (table1 #x00) s11) + (= (table1 #x01) s19) + (= (table1 #x02) s27) + (= (table1 #x03) s35) + (= (table2 #x00) s14) + (= (table2 #x01) s22) + (= (table2 #x02) s30) + (= (table2 #x03) s38) + (= (table3 #x00) s13) + (= (table3 #x01) s21) + (= (table3 #x02) s29) + (= (table3 #x03) s37) + s134)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) diff --git a/test/regress/regress1/bug543.smt2 b/test/regress/regress1/bug543.smt2 new file mode 100644 index 000000000..9155de7a9 --- /dev/null +++ b/test/regress/regress1/bug543.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +(set-option :produce-models true) +(set-logic QF_ALL_SUPPORTED) +(declare-fun _substvar_1807_ () Bool) +(declare-fun local_id_x$1 () (_ BitVec 32)) +(declare-fun local_id_x$2 () (_ BitVec 32)) +(declare-fun $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@5 () (Array Bool (Array (_ BitVec 32) (_ BitVec 32)))) +(declare-fun $$_ZZ19bitonic_sort_kernelPfjjE7sh_data () (Array Bool (Array (_ BitVec 32) (_ BitVec 32)))) +(declare-fun $0$1@2 () (_ BitVec 32)) +(declare-fun $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@0 () (Array Bool (Array (_ BitVec 32) (_ BitVec 32)))) +(declare-fun v1$1@0 () (_ BitVec 32)) +(declare-fun $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@1 () (Array Bool (Array (_ BitVec 32) (_ BitVec 32)))) +(declare-fun v1$2@0 () (_ BitVec 32)) +(assert (not (= #b1 #b0))) +(define-fun $_Z19bitonic_sort_kernelPfjj () Bool (=> true (let ((__partitioned_block_$truebb_0$7_correct (=> true (=> true (=> (and true true (= $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@5 (store $$_ZZ19bitonic_sort_kernelPfjjE7sh_data true (store (select $$_ZZ19bitonic_sort_kernelPfjjE7sh_data true) local_id_x$1 $0$1@2))) true true) false))))) (let ((inline$_UPDATE_WRITE_READ_BENIGN_FLAG_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$_UPDATE_BENIGN_FLAG_correct (=> true (=> true __partitioned_block_$truebb_0$7_correct)))) (let ((inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$_LOG_WRITE_correct (=> true (=> true inline$_UPDATE_WRITE_READ_BENIGN_FLAG_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$_UPDATE_BENIGN_FLAG_correct)))) (let ((inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$Entry_correct (=> true (=> true inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$_LOG_WRITE_correct)))) (let ((inline$$bugle_barrier$1$anon8_Then_correct (=> true (=> true inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$Entry_correct)))) (let ((inline$$bugle_barrier$1$anon3_correct (=> true (=> true (=> true (=> true inline$$bugle_barrier$1$anon8_Then_correct)))))) (let ((inline$$bugle_barrier$1$anon7_Then_correct (=> true (=> true inline$$bugle_barrier$1$anon3_correct)))) (let ((inline$$bugle_barrier$1$anon6_Else_correct (=> true (=> true (=> true (=> true inline$$bugle_barrier$1$anon7_Then_correct)))))) (let ((inline$$bugle_barrier$1$Entry_correct (=> true (=> true (=> true inline$$bugle_barrier$1$anon6_Else_correct))))) (let ((__partitioned_block_$truebb_0$4_correct (=> true (=> true (=> true inline$$bugle_barrier$1$Entry_correct))))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$4$_LOG_READ_correct (=> true (=> true __partitioned_block_$truebb_0$4_correct)))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$4$Entry_correct (=> true (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$4$_LOG_READ_correct))))) (let ((__partitioned_block_$truebb_0$3_correct (=> true (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$4$Entry_correct))))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$3$_LOG_READ_correct (=> true (=> true __partitioned_block_$truebb_0$3_correct)))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$3$Entry_correct (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$3$_LOG_READ_correct)))) (let ((__partitioned_block_$truebb_0$2_correct (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$3$Entry_correct)))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$2$_LOG_READ_correct (=> true (=> true __partitioned_block_$truebb_0$2_correct)))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$2$Entry_correct (=> true (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$2$_LOG_READ_correct))))) (let ((__partitioned_block_$truebb_0$1_correct (=> true (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$2$Entry_correct))))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$_LOG_READ_correct (=> true (=> true __partitioned_block_$truebb_0$1_correct)))) (let ((inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$Entry_correct (=> true (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$_LOG_READ_correct))))) (let ((__partitioned_block_$truebb_0_correct (=> true (=> true inline$_LOG_READ_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$1$Entry_correct)))) (let (($1_correct (=> true (=> true (=> true (=> true (=> true __partitioned_block_$truebb_0_correct))))))) (let ((__partitioned_block_$0_0$4_correct (=> true (=> true (=> true (=> true (=> true (=> true (=> true (and _substvar_1807_ (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true (=> true $1_correct)))))))))))))))))))))))))))) (let ((inline$$bugle_barrier$0$Return_correct (=> true (=> true __partitioned_block_$0_0$4_correct)))) (let ((inline$$bugle_barrier$0$anon8_Else_correct (=> true (=> true inline$$bugle_barrier$0$Return_correct)))) (let ((inline$$bugle_barrier$0$anon3_correct (=> true (=> true (=> true (=> true inline$$bugle_barrier$0$anon8_Else_correct)))))) (let ((inline$$bugle_barrier$0$anon7_Then_correct (=> true (=> true inline$$bugle_barrier$0$anon3_correct)))) (let ((inline$$bugle_barrier$0$anon6_Else_correct (=> true (=> true (=> true (=> true inline$$bugle_barrier$0$anon7_Then_correct)))))) (let ((inline$$bugle_barrier$0$Entry_correct (=> true (=> true (=> true inline$$bugle_barrier$0$anon6_Else_correct))))) (let ((__partitioned_block_$0_0$3_correct (=> true (=> true (=> (and true true (= $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@0 (store $$_ZZ19bitonic_sort_kernelPfjjE7sh_data true (store (select $$_ZZ19bitonic_sort_kernelPfjjE7sh_data true) local_id_x$1 v1$1@0))) (= $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@1 (store $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@0 false (store (select $$_ZZ19bitonic_sort_kernelPfjjE7sh_data@0 false) local_id_x$2 v1$2@0))) true) inline$$bugle_barrier$0$Entry_correct))))) (let ((inline$_UPDATE_WRITE_READ_BENIGN_FLAG_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$0$_UPDATE_BENIGN_FLAG_correct (=> true (=> true __partitioned_block_$0_0$3_correct)))) (let ((inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$0$_LOG_WRITE_correct (=> true (=> true inline$_UPDATE_WRITE_READ_BENIGN_FLAG_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$0$_UPDATE_BENIGN_FLAG_correct)))) (let ((inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$0$Entry_correct (=> true (=> true inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$0$_LOG_WRITE_correct)))) (let ((__partitioned_block_$0_0$1_correct (=> true (=> true (=> true inline$_LOG_WRITE_$$_ZZ19bitonic_sort_kernelPfjjE7sh_data$0$Entry_correct))))) (let ((inline$_LOG_READ_$$data$0$_LOG_READ_correct (=> true (=> true __partitioned_block_$0_0$1_correct)))) (let ((inline$_LOG_READ_$$data$0$Entry_correct (=> true (=> true inline$_LOG_READ_$$data$0$_LOG_READ_correct)))) (let ((__partitioned_block_$0_0_correct (=> true (=> true (=> true inline$_LOG_READ_$$data$0$Entry_correct))))) (let ((PreconditionGeneratedEntry_correct (=> true (=> true (=> true __partitioned_block_$0_0_correct))))) PreconditionGeneratedEntry_correct))))))))))))))))))))))))))))))))))))))))) +(push 1) +(assert (not (=> true $_Z19bitonic_sort_kernelPfjj))) +(check-sat) + diff --git a/test/regress/regress1/bug567.smt2 b/test/regress/regress1/bug567.smt2 new file mode 100644 index 000000000..99d7f0302 --- /dev/null +++ b/test/regress/regress1/bug567.smt2 @@ -0,0 +1,48 @@ +(set-logic ALL_SUPPORTED) +; COMMAND-LINE: --incremental --lang=smt2.5 +; EXPECT: unknown +; EXPECT: unsat +; EXPECT: unknown +(declare-datatypes () ((OptInt0 (Some (value0 Int)) (None)))) +(declare-datatypes () ((List0 (Cons (head0 Int) (tail0 List0)) (Nil)))) + +(declare-fun errorValue2 () Bool) +(declare-fun errorValue1 () Bool) + + + + + +(declare-fun size (List0) Int) +(declare-fun mergeInto (List0 List0) List0) +(declare-fun isSorted (List0) Bool) +(declare-fun buggySortedIns (Int List0) List0) +(declare-fun sortedIns (Int List0) List0) +(declare-fun sort (List0) List0) +(declare-fun contents (List0) (Set Int)) + +(assert (forall ((l List0)) (! (= (size l) (ite (is-Nil l) 0 (+ 1 (size (tail0 l))))) :pattern ((size l))))) +(assert (forall ((l1 List0) (l2 List0)) (! (= (mergeInto l1 l2) (ite (is-Nil l1) l2 (mergeInto (tail0 l1) (sortedIns (head0 l1) l2)))) :pattern ((mergeInto l1 l2))))) +(assert (forall ((l2 List0)) (! (= (isSorted l2) (ite (is-Nil l2) true (ite (and (is-Cons l2) (is-Nil (tail0 l2))) true (ite (and (is-Cons l2) (is-Cons (tail0 l2))) (and (<= (head0 l2) (head0 (tail0 l2))) (isSorted (Cons (head0 (tail0 l2)) (tail0 (tail0 l2))))) errorValue1)))) :pattern ((isSorted l2))))) +(assert (forall ((l4 List0) (e1 Int)) (! (= (buggySortedIns e1 l4) (ite (is-Nil l4) (Cons e1 Nil) (ite (<= (head0 l4) e1) (Cons (head0 l4) (buggySortedIns e1 (tail0 l4))) (Cons e1 l4)))) :pattern ((buggySortedIns e1 l4))))) +(assert (forall ((l3 List0) (e Int)) (! (= (sortedIns e l3) (ite (is-Nil l3) (Cons e Nil) (ite (<= (head0 l3) e) (Cons (head0 l3) (sortedIns e (tail0 l3))) (Cons e l3)))) :pattern ((sortedIns e l3))))) +(assert (forall ((l5 List0)) (! (= (sort l5) (ite (is-Nil l5) Nil (sortedIns (head0 l5) (sort (tail0 l5))))) :pattern ((sort l5))))) +(assert (forall ((l1 List0)) (! (= (contents l1) (ite (is-Nil l1) (as emptyset (Set Int)) (union (contents (tail0 l1)) (singleton (head0 l1))))) :pattern ((contents l1))))) + + + +(push) +(assert (forall ((l List0)) (not (let ((result (ite (is-Nil l) 0 (+ 1 (size (tail0 l)))))) (>= result 0))))) +(check-sat) +(pop) + +(push) +(assert (forall ((l2 List0)) (not (not (and (not (is-Nil l2)) (not (and (is-Cons l2) (is-Nil (tail0 l2)))) (not (and (is-Cons l2) (is-Cons (tail0 l2))))))))) +(check-sat) +(pop) + +(push) +(assert (forall ((l4 List0) (e1 Int)) (not (let ((result2 (ite (is-Nil l4) (Cons e1 Nil) (ite (<= (head0 l4) e1) (Cons (head0 l4) (buggySortedIns e1 (tail0 l4))) (Cons e1 l4))))) (and (= (contents result2) (union (contents l4) (singleton e1))) (isSorted result2) (= (size result2) (+ (size l4) 1))))))) +(check-sat) +(pop) + diff --git a/test/regress/regress1/bug585.cvc b/test/regress/regress1/bug585.cvc new file mode 100644 index 000000000..825cb0003 --- /dev/null +++ b/test/regress/regress1/bug585.cvc @@ -0,0 +1,9 @@ +% EXPECT: sat + +Cache: TYPE = ARRAY [0..100] OF [# addr: INT, data: REAL #]; +State: TYPE = [# pc: INT, cache: Cache #]; + +s0: State; +s1: State = s0 WITH .cache[10].data := 2/3; + +CHECKSAT; diff --git a/test/regress/regress1/bug590.smt2 b/test/regress/regress1/bug590.smt2 new file mode 100644 index 000000000..68665f629 --- /dev/null +++ b/test/regress/regress1/bug590.smt2 @@ -0,0 +1,61 @@ +(set-logic QF_ALL_SUPPORTED) +(set-option :strings-exp true) +(set-option :produce-models true) +(set-info :smt-lib-version 2.0) +(set-info :status unknown) + +(declare-fun text () String) +(declare-fun output () String) + +; html_escape_table = { +; "&": "&", +; '"': """, +; "'": "'", +; ">": ">", +; "<": "<", +; } +(declare-fun html_escape_table () (Array String String)) +(assert (= html_escape_table + (store (store (store (store (store ((as const (Array String String)) "A") + "&" "&") + "\"" """) + "'" "'") + ">" ">") + "<" "<"))) +(declare-fun html_escape_table_keys () (Array Int String)) +(assert (= html_escape_table_keys + (store (store (store (store (store ((as const (Array Int String)) "B") + 0 "&") + 1 "\"") + 2 "'") + 3 ">") + 4 "<"))) + +; charlst = [c for c in text] +(declare-fun charlst () (Array Int String)) +(declare-fun charlstlen () Int) +(assert (= charlstlen (str.len text))) +(assert (forall ((i Int)) + (= (select charlst i) (str.at text i)) +)) + +; charlst2 = [html_escape_table.get(c, c) for c in charlst] +(declare-fun charlst2 () (Array Int String)) +(declare-fun charlstlen2 () Int) +(assert (= charlstlen2 charlstlen)) +(assert (forall ((i Int)) + (or (or (< i 0) (>= i charlstlen2)) + (and (exists ((j Int)) + (= (select html_escape_table_keys j) (select charlst i)) + ) + (= (select charlst2 i) (select html_escape_table (select charlst i))) + ) + (and (not (exists ((j Int)) + (= (select html_escape_table_keys j) (select charlst i)) + )) + (= (select charlst2 i) (select charlst i)) + ) + ) +)) +(check-sat) +(get-value (charlst2)) diff --git a/test/regress/regress1/bug590.smt2.expect b/test/regress/regress1/bug590.smt2.expect new file mode 100644 index 000000000..b24a807f7 --- /dev/null +++ b/test/regress/regress1/bug590.smt2.expect @@ -0,0 +1,2 @@ +% EXPECT: unknown +% EXPECT: ((charlst2 ((as const (Array Int String)) ""))) diff --git a/test/regress/regress1/bug593.smt2 b/test/regress/regress1/bug593.smt2 new file mode 100644 index 000000000..2c28bb47c --- /dev/null +++ b/test/regress/regress1/bug593.smt2 @@ -0,0 +1,20 @@ +(set-logic QF_UFBV) +(set-info :status unsat) + +(declare-sort A 0) + +(declare-fun f ((_ BitVec 1)) A) +(declare-fun g (A) (_ BitVec 1)) + +(declare-fun x () A) +(declare-fun y () A) +(declare-fun z () A) + +(assert (and + +(not (= (f (g x)) (f (g y)))) +(not (= (f (g x)) (f (g z)))) +(not (= (f (g y)) (f (g z)))))) + +(check-sat) + diff --git a/test/regress/regress1/bug681.smt2 b/test/regress/regress1/bug681.smt2 new file mode 100644 index 000000000..93d7b88c4 --- /dev/null +++ b/test/regress/regress1/bug681.smt2 @@ -0,0 +1,55 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXIT: 1 +; EXPECT: (error "Array theory solver does not yet support write-chains connecting two different constant arrays") +(set-logic ALL_SUPPORTED) +(declare-fun start!1 () Bool) + +(assert start!1) + +(declare-fun lt!2 () Bool) + +(assert (=> start!1 (not lt!2))) + +(declare-datatypes () ( (Option!3 (None!1) (Some!1 (v!18 Int))) )) + +(declare-datatypes () ( (Method!1 (Method!2 (initials!1 (Array Option!3 Int)))) )) + +(declare-fun lambda!2 () (Array Int Method!1)) + +(declare-fun isValidStep!1 ((Array Int Method!1) (Array Int Option!3) (Array Int Option!3) Int Int Option!3) Bool) + +(declare-fun control!1 () (Array Int Option!3)) + +(declare-fun next_control!0 () (Array Int Option!3)) + +(assert (=> start!1 (= lt!2 (not (isValidStep!1 lambda!2 control!1 next_control!0 0 0 (Some!1 5)))))) + +(declare-fun d!1 () Bool) + +(assert (=> d!1 (= (isValidStep!1 lambda!2 control!1 next_control!0 0 0 (Some!1 5)) (= next_control!0 (store control!1 0 (Some!1 (select (initials!1 (select lambda!2 0)) (Some!1 5)))))))) + +(declare-fun methods!1 (Int) Method!1) + +(assert (=> d!1 (= (select lambda!2 0) (methods!1 0)))) + +(declare-fun b_lambda!1 () Bool) + +(assert (=> (not b_lambda!1) (not d!1))) + +(assert (=> start!1 d!1)) + +(declare-fun d!3 () Bool) + +(assert (=> d!3 (= control!1 ((as const (Array Int Option!3)) None!1)))) + +(assert (=> start!1 d!3)) + +(declare-fun d!5 () Bool) + +(assert (=> d!5 (= next_control!0 (store ((as const (Array Int Option!3)) None!1) 0 (Some!1 0))))) + +(assert (=> start!1 d!5)) + +(assert true) + +(check-sat) diff --git a/test/regress/regress1/bug694-Unapply1.scala-0.smt2 b/test/regress/regress1/bug694-Unapply1.scala-0.smt2 new file mode 100644 index 000000000..7680a7daf --- /dev/null +++ b/test/regress/regress1/bug694-Unapply1.scala-0.smt2 @@ -0,0 +1,147 @@ +; COMMAND-LINE: --incremental --lang=smt2.5 +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +(set-logic ALL) +(declare-fun start!1 () Bool) + +(assert start!1) + +(declare-fun b!15 () Bool) + +(declare-fun e!22 () Bool) + +(declare-fun error_value!0 () Bool) + +(assert (=> b!15 (= e!22 error_value!0))) + +(declare-fun b!16 () Bool) + +(declare-fun e!20 () Bool) + +(assert (=> b!16 (= e!20 e!22))) + +(declare-fun b!20 () Bool) + +(declare-datatypes () ( (Option!3 (None!1) (Some!1 (v!71 tuple2!0))) (tuple2!0 (tuple2!1 (_1!0 Unit!0) (_2!0 Bool))) (Unit!0 (Unit!1)) )) + +(declare-fun lt!7 () Option!3) + +(declare-fun Unit!2 () Unit!0) + +(assert (=> b!16 (= b!20 (ite (is-Some!1 lt!7) (= (_1!0 (v!71 lt!7)) Unit!2) false)))) + +(assert (=> b!16 (or (not b!20) (not b!15)))) + +(assert (=> b!16 (or b!20 b!15))) + +(declare-datatypes () ( (tuple3!0 (tuple3!1 (_1!1 (_ BitVec 32)) (_2!1 Bool) (_3!0 Unit!0))) )) + +(declare-fun unapply!2 (tuple3!0) Option!3) + +(declare-fun Unit!3 () Unit!0) + +(assert (=> b!16 (= lt!7 (unapply!2 (tuple3!1 #x0000002A false Unit!3))))) + +(declare-fun b!17 () Bool) + +(declare-fun e!21 () Bool) + +(assert (=> b!17 e!21)) + +(declare-fun b!18 () Bool) + +(declare-fun Unit!4 () Unit!0) + +(assert (=> b!18 (= e!20 (_2!0 (v!71 (unapply!2 (tuple3!1 #x0000002A false Unit!4))))))) + +(declare-fun lt!6 () Bool) + +(assert (=> start!1 (not lt!6))) + +(assert (=> start!1 (= lt!6 e!20))) + +(assert (=> start!1 (= b!18 e!21))) + +(assert (=> start!1 (or (not b!18) (not b!16)))) + +(assert (=> start!1 (or b!18 b!16))) + +(declare-fun b!19 () Bool) + +(assert (=> (and start!1 (not b!19)) (not e!21))) + +(declare-fun lt!8 () Option!3) + +(assert (=> start!1 (= b!19 (ite (is-Some!1 lt!8) true false)))) + +(declare-fun Unit!5 () Unit!0) + +(assert (=> start!1 (= lt!8 (unapply!2 (tuple3!1 #x0000002A false Unit!5))))) + +(assert (=> (and b!19 (not b!17)) (not e!21))) + +(declare-fun Unit!6 () Unit!0) + +(assert (=> b!19 (= b!17 (_2!0 (v!71 (unapply!2 (tuple3!1 #x0000002A false Unit!6))))))) + +(declare-fun Unit!7 () Unit!0) + +(assert (=> b!20 (= e!22 (_2!0 (v!71 (unapply!2 (tuple3!1 #x0000002A false Unit!7))))))) + +(push 1) + +(assert (and (and (and (and (not b!19) (not start!1)) (not b!20)) (not b!18)) (not b!16))) + +(check-sat) + +(pop 1) + +(push 1) + +(assert true) + +(check-sat) + +(pop 1) + +(declare-fun d!1 () Bool) + +(declare-fun e!25 () Bool) + +(assert (=> d!1 e!25)) + +(declare-fun b!23 () Bool) + +(assert (=> (and d!1 (not b!23)) (not e!25))) + +(declare-fun Unit!8 () Unit!0) + +(declare-fun Unit!9 () Unit!0) + +(declare-fun Unit!10 () Unit!0) + +(declare-fun Unit!11 () Unit!0) + +(assert (=> d!1 (= b!23 (= (unapply!2 (tuple3!1 #x0000002A false Unit!8)) (ite (= (_1!1 (tuple3!1 #x0000002A false Unit!9)) #x00000000) None!1 (Some!1 (tuple2!1 (_3!0 (tuple3!1 #x0000002A false Unit!10)) (_2!1 (tuple3!1 #x0000002A false Unit!11))))))))) + +(assert (=> b!23 (= e!25 true))) + +(assert (=> b!18 d!1)) + +(assert (=> start!1 d!1)) + +(assert (=> b!16 d!1)) + +(assert (=> b!20 d!1)) + +(assert (=> b!19 d!1)) + +(push 1) + +(assert true) + +(check-sat) + +(pop 1) + diff --git a/test/regress/regress1/bug800.smt2 b/test/regress/regress1/bug800.smt2 new file mode 100644 index 000000000..d36f62b16 --- /dev/null +++ b/test/regress/regress1/bug800.smt2 @@ -0,0 +1,168 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +(set-logic QF_UFLRA) +(set-info :source |CPAchecker with bounded model checking on SV-COMP14 program using MathSAT5, submitted by Philipp Wendler, http://cpachecker.sosy-lab.org|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") + + +(declare-fun |__ADDRESS_OF_main::c1| () Real) +(declare-fun |__ADDRESS_OF_main::x1| () Real) +(declare-fun |__ADDRESS_OF_main::x2| () Real) +(declare-fun |__ADDRESS_OF_main::c2| () Real) +(declare-fun |main::x3@3| () Real) +(declare-fun |main::x1@3| () Real) +(declare-fun |__ADDRESS_OF_main::d3| () Real) +(declare-fun __BASE_ADDRESS_OF__ (Real) Real) +(declare-fun |main::x2@3| () Real) +(declare-fun |main::d3@2| () Real) +(declare-fun |__VERIFIER_assert::cond@2| () Real) +(declare-fun |__ADDRESS_OF_main::x3| () Real) +(declare-fun |main::d1@2| () Real) +(declare-fun |__ADDRESS_OF_main::d2| () Real) +(declare-fun |__ADDRESS_OF_main::__CPAchecker_TMP_0| () Real) +(declare-fun |main::__CPAchecker_TMP_0@3| () Real) +(declare-fun |__ADDRESS_OF_main::d1| () Real) +(declare-fun |main::d2@2| () Real) +(define-fun _7 () Real 0) +(define-fun _8 () Real |__ADDRESS_OF_main::x1|) +(define-fun _9 () Real (__BASE_ADDRESS_OF__ _8)) +(define-fun _10 () Bool (= _8 _9)) +(define-fun _11 () Real |__ADDRESS_OF_main::x2|) +(define-fun _12 () Real (__BASE_ADDRESS_OF__ _11)) +(define-fun _13 () Bool (= _11 _12)) +(define-fun _14 () Bool (and _10 _13)) +(define-fun _15 () Real |__ADDRESS_OF_main::x3|) +(define-fun _16 () Real (__BASE_ADDRESS_OF__ _15)) +(define-fun _17 () Bool (= _15 _16)) +(define-fun _18 () Bool (and _14 _17)) +(define-fun _19 () Real |__ADDRESS_OF_main::d1|) +(define-fun _20 () Real (__BASE_ADDRESS_OF__ _19)) +(define-fun _21 () Bool (= _19 _20)) +(define-fun _22 () Real 1) +(define-fun _23 () Real |main::d1@2|) +(define-fun _24 () Bool (= _23 _22)) +(define-fun _25 () Bool (and _21 _24)) +(define-fun _26 () Bool (and _18 _25)) +(define-fun _27 () Real |__ADDRESS_OF_main::d2|) +(define-fun _28 () Real (__BASE_ADDRESS_OF__ _27)) +(define-fun _29 () Bool (= _27 _28)) +(define-fun _30 () Real |main::d2@2|) +(define-fun _31 () Bool (= _30 _22)) +(define-fun _32 () Bool (and _29 _31)) +(define-fun _33 () Bool (and _26 _32)) +(define-fun _34 () Real |__ADDRESS_OF_main::d3|) +(define-fun _35 () Real (__BASE_ADDRESS_OF__ _34)) +(define-fun _36 () Bool (= _34 _35)) +(define-fun _37 () Real |main::d3@2|) +(define-fun _38 () Bool (= _37 _22)) +(define-fun _39 () Bool (and _36 _38)) +(define-fun _40 () Bool (and _33 _39)) +(define-fun _41 () Real |__ADDRESS_OF_main::c1|) +(define-fun _42 () Real (__BASE_ADDRESS_OF__ _41)) +(define-fun _43 () Bool (= _41 _42)) +(define-fun _44 () Bool (and _40 _43)) +(define-fun _45 () Real |__ADDRESS_OF_main::c2|) +(define-fun _46 () Real (__BASE_ADDRESS_OF__ _45)) +(define-fun _47 () Bool (= _45 _46)) +(define-fun _48 () Bool (and _44 _47)) +(define-fun _49 () Real |main::x1@3|) +(define-fun _50 () Bool (<= _49 _7)) +(define-fun _51 () Bool (not _50)) +(define-fun _53 () Bool (and _48 _51)) +(define-fun _54 () Bool (and _48 _50)) +(define-fun _55 () Real |main::x2@3|) +(define-fun _56 () Bool (<= _55 _7)) +(define-fun _57 () Bool (not _56)) +(define-fun _59 () Bool (and _53 _57)) +(define-fun _60 () Bool (and _53 _56)) +(define-fun _61 () Bool (or _54 _60)) +(define-fun _62 () Real |main::x3@3|) +(define-fun _63 () Bool (<= _62 _7)) +(define-fun _67 () Bool (and _59 _63)) +(define-fun _68 () Bool (or _61 _67)) +(define-fun _69 () Real |__ADDRESS_OF_main::__CPAchecker_TMP_0|) +(define-fun _70 () Real (__BASE_ADDRESS_OF__ _69)) +(define-fun _71 () Bool (= _69 _70)) +(define-fun _72 () Bool (and _68 _71)) +(define-fun _73 () Bool (= _49 _7)) +(define-fun _75 () Bool (and _72 _73)) +(define-fun _76 () Bool (not _73)) +(define-fun _77 () Bool (and _72 _76)) +(define-fun _78 () Bool (= _55 _7)) +(define-fun _80 () Bool (and _77 _78)) +(define-fun _81 () Bool (not _78)) +(define-fun _82 () Bool (and _77 _81)) +(define-fun _83 () Bool (or _75 _80)) +(define-fun _84 () Bool (= _62 _7)) +(define-fun _86 () Bool (and _82 _84)) +(define-fun _87 () Bool (not _84)) +(define-fun _88 () Bool (and _82 _87)) +(define-fun _89 () Bool (or _83 _86)) +(define-fun _90 () Real |main::__CPAchecker_TMP_0@3|) +(define-fun _91 () Bool (= _90 _7)) +(define-fun _92 () Bool (and _88 _91)) +(define-fun _93 () Bool (= _90 _22)) +(define-fun _94 () Bool (and _89 _93)) +(define-fun _95 () Bool (or _92 _94)) +(define-fun _96 () Real |__VERIFIER_assert::cond@2|) +(define-fun _97 () Bool (= _90 _96)) +(define-fun _98 () Bool (and _95 _97)) +(define-fun _99 () Bool (= _96 _7)) +(define-fun _101 () Bool (and _98 _99)) +(declare-fun __ART__34@0 () Bool) +(declare-fun |main::c2@3| () Real) +(declare-fun __ART__24@0 () Bool) +(declare-fun __ART__45@0 () Bool) +(declare-fun |main::c1@3| () Real) +(declare-fun __ART__23@0 () Bool) +(declare-fun __ART__32@0 () Bool) +(declare-fun __ART__36@0 () Bool) +(declare-fun __ART__26@0 () Bool) +(declare-fun __ART__53@0 () Bool) +(declare-fun __ART__29@0 () Bool) +(define-fun _64 () Bool (not _63)) +(define-fun _108 () Real |main::c1@3|) +(define-fun _109 () Bool (= _108 _7)) +(define-fun _123 () Real |main::c2@3|) +(define-fun _124 () Bool (= _123 _7)) +(define-fun _160 () Bool __ART__23@0) +(define-fun _161 () Bool (= _51 _160)) +(define-fun _162 () Bool __ART__24@0) +(define-fun _163 () Bool (= _57 _162)) +(define-fun _164 () Bool (and _161 _163)) +(define-fun _165 () Bool __ART__26@0) +(define-fun _166 () Bool (= _64 _165)) +(define-fun _167 () Bool (and _164 _166)) +(define-fun _168 () Bool __ART__29@0) +(define-fun _169 () Bool (= _109 _168)) +(define-fun _170 () Bool (and _167 _169)) +(define-fun _171 () Bool __ART__32@0) +(define-fun _172 () Bool (= _73 _171)) +(define-fun _173 () Bool (and _170 _172)) +(define-fun _174 () Bool __ART__34@0) +(define-fun _175 () Bool (= _78 _174)) +(define-fun _176 () Bool (and _173 _175)) +(define-fun _177 () Bool __ART__36@0) +(define-fun _178 () Bool (= _84 _177)) +(define-fun _179 () Bool (and _176 _178)) +(define-fun _180 () Bool __ART__45@0) +(define-fun _181 () Bool (= _99 _180)) +(define-fun _182 () Bool (and _179 _181)) +(define-fun _183 () Bool __ART__53@0) +(define-fun _184 () Bool (= _124 _183)) +(define-fun _185 () Bool (and _182 _184)) + + +(push 1) +(assert _101) +(set-info :status sat) +(check-sat) +(push 1) +(assert _185) +(set-info :status sat) +(check-sat) +(pop 1) +(pop 1) +(exit) diff --git a/test/regress/regress1/bv/Makefile.am b/test/regress/regress1/bv/Makefile.am index fa58e0dee..b144a0507 100644 --- a/test/regress/regress1/bv/Makefile.am +++ b/test/regress/regress1/bv/Makefile.am @@ -19,10 +19,22 @@ endif TESTS = \ bv-proof00.smt \ fuzz34.smt \ - fuzz38.smt + fuzz38.smt \ + bug_extract_mult_leading_bit.smt2 \ + bug787.smt2 \ + bv-int-collapse2-sat.smt2 \ + cmu-rdk-3.smt2 \ + decision-weight00.smt2 \ + divtest.smt2 \ + bv2nat-ground.smt2 \ + bv2nat-simp-range-sat.smt2 \ + unsound1.smt2 EXTRA_DIST = $(TESTS) +# This benchmark is currently disabled as it uses --check-proof +# bench_38.delta.smt2 + # synonyms for "check" in this directory .PHONY: regress regress1 test regress regress1 test: check diff --git a/test/regress/regress1/bv/bench_38.delta.smt2 b/test/regress/regress1/bv/bench_38.delta.smt2 new file mode 100644 index 000000000..760614348 --- /dev/null +++ b/test/regress/regress1/bv/bench_38.delta.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --fewer-preprocessing-holes --check-proof --quiet +; EXPECT: unsat +(set-logic QF_BV) +(declare-fun x () (_ BitVec 4)) +(assert (and (= (bvudiv (_ bv2 4) x) (_ bv2 4)) (= (_ bv0 4) x) (= (_ bv1 4) x))) +(check-sat) +(exit) diff --git a/test/regress/regress1/bv/bug787.smt2 b/test/regress/regress1/bv/bug787.smt2 new file mode 100644 index 000000000..8e0ba0016 --- /dev/null +++ b/test/regress/regress1/bv/bug787.smt2 @@ -0,0 +1,91 @@ +; COMMAND-LINE: --bitblast=eager --no-check-proofs +; EXPECT: unsat +(set-logic QF_BV) +(set-info :status unsat) +(define-fun hamming-weight ((bv (_ BitVec 4))) (_ BitVec 4) + (bvadd + (bvadd + (bvadd ((_ zero_extend 3) ((_ extract 0 0) bv)) + ((_ zero_extend 3) ((_ extract 1 1) bv))) + ((_ zero_extend 3) ((_ extract 2 2) bv))) + ((_ zero_extend 3) ((_ extract 3 3) bv)))) +(define-fun left-hamming-weight ((index (_ BitVec 4)) (bv (_ BitVec 4))) + (_ BitVec 4) + (hamming-weight (bvand bv (bvnot (bvsub (bvshl index (_ bv1 4)) (_ bv1 4)))))) +(define-fun right-hamming-weight ((index (_ BitVec 4)) (bv (_ BitVec 4))) + (_ BitVec 4) (hamming-weight (bvand bv (bvsub index (_ bv1 4))))) +(define-fun bit-1 ((bv (_ BitVec 4))) (_ BitVec 4) (bvand bv (bvneg bv))) +(define-fun bit-2 ((bv (_ BitVec 4))) (_ BitVec 4) + (bit-1 (bvand bv (bvsub bv (_ bv1 4))))) +(define-fun bit-3 ((bv (_ BitVec 4))) (_ BitVec 4) + (bit-2 (bvand bv (bvsub bv (_ bv1 4))))) +(define-fun bit-4 ((bv (_ BitVec 4))) (_ BitVec 4) + (bit-3 (bvand bv (bvsub bv (_ bv1 4))))) +(define-fun bit-5 ((bv (_ BitVec 4))) (_ BitVec 4) + (bit-4 (bvand bv (bvsub bv (_ bv1 4))))) +(define-fun index-bit ((index (_ BitVec 4)) (bv (_ BitVec 4))) (_ BitVec 4) + (ite (= index (_ bv0 4)) (bit-1 bv) + (ite (= index (_ bv1 4)) (bit-2 bv) + (ite (= index (_ bv2 4)) (bit-3 bv) (bit-4 bv))))) +(define-fun permute + ((index (_ BitVec 4)) (obj-0 (_ BitVec 4)) (obj-1 (_ BitVec 4)) + (obj-2 (_ BitVec 4)) (obj-3 (_ BitVec 4))) + (_ BitVec 4) + (let ((my-index-bit (bvshl (_ bv1 4) index))) + (ite (= my-index-bit obj-0) (_ bv0 4) + (ite (= my-index-bit obj-1) (_ bv1 4) + (ite (= my-index-bit obj-2) (_ bv2 4) (_ bv3 4)))))) +(define-fun left-zeros ((index (_ BitVec 4))) (_ BitVec 8) + (ite (bvugt index (_ bv2 4)) (ite (bvugt index (_ bv4 4)) (_ bv0 8) (_ bv1 8)) + (ite (bvugt index (_ bv1 4)) (_ bv2 8) (_ bv3 8)))) +(define-fun centered ((index (_ BitVec 4)) (bv (_ BitVec 4))) (_ BitVec 8) + (bvshl ((_ zero_extend 4) bv) (left-zeros index))) +(declare-const v0 (_ BitVec 4)) +(assert (= (_ bv4 4) (hamming-weight v0))) +(declare-const v1 (_ BitVec 4)) +(assert (= (_ bv4 4) (hamming-weight v1))) +(declare-const vp1-0 (_ BitVec 4)) +(assert + (or (= (_ bv1 4) vp1-0) (= (_ bv2 4) vp1-0) (= (_ bv4 4) vp1-0) + (= (_ bv8 4) vp1-0))) +(declare-const vp1-1 (_ BitVec 4)) +(assert + (or (= (_ bv1 4) vp1-1) (= (_ bv2 4) vp1-1) (= (_ bv4 4) vp1-1) + (= (_ bv8 4) vp1-1))) +(declare-const vp1-2 (_ BitVec 4)) +(assert + (or (= (_ bv1 4) vp1-2) (= (_ bv2 4) vp1-2) (= (_ bv4 4) vp1-2) + (= (_ bv8 4) vp1-2))) +(declare-const vp1-3 (_ BitVec 4)) +(assert + (or (= (_ bv1 4) vp1-3) (= (_ bv2 4) vp1-3) (= (_ bv4 4) vp1-3) + (= (_ bv8 4) vp1-3))) +(assert (= (_ bv15 4) (bvor vp1-0 (bvor vp1-1 (bvor vp1-2 vp1-3))))) +(assert + (and + (= (_ bv0 8) + (bvxor + (bvand + (centered (index-bit (permute (_ bv0 4) vp1-0 vp1-1 vp1-2 vp1-3) v1) v1) + (centered (index-bit (_ bv0 4) v0) v0)) + (_ bv8 8))) + (= (_ bv0 8) + (bvxor + (bvand + (centered (index-bit (permute (_ bv1 4) vp1-0 vp1-1 vp1-2 vp1-3) v1) v1) + (centered (index-bit (_ bv1 4) v0) v0)) + (_ bv8 8))) + (= (_ bv0 8) + (bvxor + (bvand + (centered (index-bit (permute (_ bv2 4) vp1-0 vp1-1 vp1-2 vp1-3) v1) v1) + (centered (index-bit (_ bv2 4) v0) v0)) + (_ bv8 8))) + (= (_ bv0 8) + (bvxor + (bvand + (centered (index-bit (permute (_ bv3 4) vp1-0 vp1-1 vp1-2 vp1-3) v1) v1) + (centered (index-bit (_ bv3 4) v0) v0)) + (_ bv8 8))))) +(check-sat) + diff --git a/test/regress/regress1/bv/bug_extract_mult_leading_bit.smt2 b/test/regress/regress1/bv/bug_extract_mult_leading_bit.smt2 new file mode 100644 index 000000000..8e3728587 --- /dev/null +++ b/test/regress/regress1/bv/bug_extract_mult_leading_bit.smt2 @@ -0,0 +1,7 @@ +(set-logic QF_BV) +(set-info :status sat) +(declare-fun x1 () (_ BitVec 15)) +(declare-fun x2 () (_ BitVec 15)) +(assert (not (= ((_ extract 64 60) (bvmul (concat #b00000000000000000000000000000000000000000000000000 x1) (concat #b10000000000000000000000000000000000000000000000000 x2))) #b00000))) +(check-sat) +(exit) diff --git a/test/regress/regress1/bv/bv-int-collapse2-sat.smt2 b/test/regress/regress1/bv/bv-int-collapse2-sat.smt2 new file mode 100644 index 000000000..4b97a3de9 --- /dev/null +++ b/test/regress/regress1/bv/bv-int-collapse2-sat.smt2 @@ -0,0 +1,8 @@ +; COMMAND-LINE: --rewrite-divk --no-check-proofs --no-check-unsat-cores +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-fun t () Int) +(assert (> t 0)) +(assert (not (= t (bv2nat ((_ int2bv 16) t))))) +(check-sat) diff --git a/test/regress/regress1/bv/bv2nat-ground.smt2 b/test/regress/regress1/bv/bv2nat-ground.smt2 new file mode 100644 index 000000000..bfc22850e --- /dev/null +++ b/test/regress/regress1/bv/bv2nat-ground.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --no-check-proofs --no-check-unsat-cores +; EXPECT: unsat +(set-logic QF_BVLIA) +(set-info :status unsat) +(declare-const a (_ BitVec 32)) +(declare-const b (_ BitVec 32)) +(declare-const c (_ BitVec 32)) +(declare-const d (_ BitVec 32)) +(declare-const e (_ BitVec 32)) + +(assert (or (= a b) (= a c) (= a d) (= a e))) + +(assert (not (= (bv2nat a) (bv2nat b)))) +(assert (not (= (bv2nat a) (bv2nat c)))) +(assert (not (= (bv2nat a) (bv2nat d)))) +(assert (not (= (bv2nat a) (bv2nat e)))) + +(check-sat) diff --git a/test/regress/regress1/bv/bv2nat-simp-range-sat.smt2 b/test/regress/regress1/bv/bv2nat-simp-range-sat.smt2 new file mode 100644 index 000000000..7e98460b8 --- /dev/null +++ b/test/regress/regress1/bv/bv2nat-simp-range-sat.smt2 @@ -0,0 +1,5 @@ +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-fun t () (_ BitVec 16)) +(assert (not (and (<= 0 (bv2nat t)) (< (bv2nat t) 65535)))) +(check-sat) diff --git a/test/regress/regress1/bv/cmu-rdk-3.smt2 b/test/regress/regress1/bv/cmu-rdk-3.smt2 new file mode 100644 index 000000000..9e7733889 --- /dev/null +++ b/test/regress/regress1/bv/cmu-rdk-3.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --rewrite-divk +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) + +(declare-fun y () Int) +(declare-fun x () Int) + +(assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (not (not (= (ite (= (bv2nat (bvand ((_ int2bv 3) (bv2nat (bvor ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))) ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1))))))) ((_ int2bv 3) 1))) 0) 1 0) 0)))) (not (= (ite (>= x 0) 1 0) 0))) (not (= (ite (>= y 0) 1 0) 0))) (not (= (ite (= x y) 1 0) 0))) (not (not (= (ite (= x 0) 1 0) 0)))) (not (not (= (ite (= y 0) 1 0) 0)))) (not (= (ite (= (bv2nat (bvand ((_ int2bv 3) (bv2nat (bvor ((_ int2bv 3) x) ((_ int2bv 3) x)))) ((_ int2bv 3) 1))) 0) 1 0) 0))) (and (= x (bv2nat ((_ int2bv 3) x))) (= 1 (bv2nat ((_ int2bv 3) 1))))) (= ((_ extract 0 0) (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1))) (_ bv0 1))) (and (= y (bv2nat ((_ int2bv 3) y))) (= 1 (bv2nat ((_ int2bv 3) 1))))) (= ((_ extract 0 0) (bvashr ((_ int2bv 3) y) ((_ int2bv 3) 1))) (_ bv0 1))) (and (= (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1))) (bv2nat ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))))) (= (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1))) (bv2nat ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))))))) (= ((_ extract 0 0) (bvor ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))) ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))))) (_ bv0 1))) (and (= (bv2nat (bvor ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))) ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))))) (bv2nat ((_ int2bv 3) (bv2nat (bvor ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))) ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1))))))))) (= 1 (bv2nat ((_ int2bv 3) 1))))) (= ((_ extract 0 0) (bvand ((_ int2bv 3) (bv2nat (bvor ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1)))) ((_ int2bv 3) (bv2nat (bvashr ((_ int2bv 3) x) ((_ int2bv 3) 1))))))) ((_ int2bv 3) 1))) (_ bv0 1))) (and (= x (bv2nat ((_ int2bv 3) x))) (= x (bv2nat ((_ int2bv 3) x))))) (= ((_ extract 0 0) (bvor ((_ int2bv 3) x) ((_ int2bv 3) x))) (_ bv0 1))) (and (= (bv2nat (bvor ((_ int2bv 3) x) ((_ int2bv 3) x))) (bv2nat ((_ int2bv 3) (bv2nat (bvor ((_ int2bv 3) x) ((_ int2bv 3) x)))))) (= 1 (bv2nat ((_ int2bv 3) 1))))) (= ((_ extract 0 0) (bvand ((_ int2bv 3) (bv2nat (bvor ((_ int2bv 3) x) ((_ int2bv 3) x)))) ((_ int2bv 3) 1))) (_ bv0 1)))) + +(check-sat) diff --git a/test/regress/regress1/bv/decision-weight00.smt2 b/test/regress/regress1/bv/decision-weight00.smt2 new file mode 100644 index 000000000..be52810e0 --- /dev/null +++ b/test/regress/regress1/bv/decision-weight00.smt2 @@ -0,0 +1,20 @@ +(set-option :produce-models true) +(set-logic QF_BV) +(set-info :status sat) +(set-info :source | + Patrice Godefroid, SAGE (systematic dynamic test generation) + For more information: http://research.microsoft.com/en-us/um/people/pg/public_psfiles/ndss2008.pdf +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unknown) +(declare-fun x () (_ BitVec 32)) +(declare-fun y () (_ BitVec 32)) +(declare-fun z () (_ BitVec 4)) +(assert (or + (= x (bvmul x y)) + (and (= x y) + (not (= ((_ extract 2 2) x) ((_ extract 2 2) z)))) + )) +(check-sat) +(exit) diff --git a/test/regress/regress1/bv/divtest.smt2 b/test/regress/regress1/bv/divtest.smt2 new file mode 100644 index 000000000..fe91cb87b --- /dev/null +++ b/test/regress/regress1/bv/divtest.smt2 @@ -0,0 +1,53 @@ +(set-logic QF_BV) +(set-info :status unsat) +(declare-fun x1 () (_ BitVec 12)) +(declare-fun x2 () (_ BitVec 12)) +(declare-fun x3 () (_ BitVec 12)) + +(declare-fun y1 () (_ BitVec 12)) +(declare-fun y2 () (_ BitVec 12)) +(declare-fun y3 () (_ BitVec 12)) + +(declare-fun z1 () (_ BitVec 12)) +(declare-fun z2 () (_ BitVec 12)) +(declare-fun z3 () (_ BitVec 12)) + +(declare-fun a () (_ BitVec 12)) + +(declare-fun x01 () (_ BitVec 10)) +(declare-fun x02 () (_ BitVec 10)) +(declare-fun x03 () (_ BitVec 10)) + +(declare-fun y01 () (_ BitVec 10)) +(declare-fun y02 () (_ BitVec 10)) +(declare-fun y03 () (_ BitVec 10)) + +(declare-fun z01 () (_ BitVec 10)) +(declare-fun z02 () (_ BitVec 10)) +(declare-fun z03 () (_ BitVec 10)) + +(declare-fun a0 () (_ BitVec 10)) + +(assert +(or +(and + (= a (_ bv0 12)) + (or (not (= (bvudiv x1 a) (bvudiv x2 a))) + (not (= (bvudiv x1 a) (bvudiv x3 a))) + (not (= (bvudiv x2 a) (bvudiv x3 a)))) + (or (and (= x1 y1) (= y1 x2)) + (and (= x1 z1) (= z1 x2))) + (or (and (= x2 y2) (= y2 x3)) + (and (= x2 z2) (= z2 x3)))) + +(and + (= a0 (_ bv0 10)) + (or (not (= (bvurem x01 a0) (bvurem x02 a0))) + (not (= (bvurem x01 a0) (bvurem x03 a0))) + (not (= (bvurem x02 a0) (bvurem x03 a0)))) + (or (and (= x01 y01) (= y01 x02)) + (and (= x01 z01) (= z01 x02))) + (or (and (= x02 y02) (= y02 x03)) + (and (= x02 z02) (= z02 x03)))))) + +(check-sat) diff --git a/test/regress/regress1/bv/unsound1.smt2 b/test/regress/regress1/bv/unsound1.smt2 new file mode 100644 index 000000000..60e764537 --- /dev/null +++ b/test/regress/regress1/bv/unsound1.smt2 @@ -0,0 +1,23 @@ +(set-logic QF_BV) +(set-info :status sat) +(declare-fun v0 () (_ BitVec 4)) +(assert (let ((e1(_ bv0 1))) +(let ((e2(_ bv11134 16))) +(let ((e3 (bvadd e2 ((_ sign_extend 12) v0)))) +(let ((e4 (ite (= e2 ((_ sign_extend 12) v0)) (_ bv1 1) (_ bv0 1)))) +(let ((e5 (bvlshr e3 ((_ sign_extend 12) v0)))) +(let ((e6 (bvxnor e2 ((_ zero_extend 12) v0)))) +(let ((e7 (ite (bvult ((_ sign_extend 15) e1) e2) (_ bv1 1) (_ bv0 1)))) +(let ((e8 (bvugt e7 e1))) +(let ((e9 (bvule ((_ sign_extend 3) e7) v0))) +(let ((e10 (bvsgt e5 ((_ zero_extend 12) v0)))) +(let ((e11 (= e6 e3))) +(let ((e12 (bvslt ((_ zero_extend 15) e4) e5))) +(let ((e13 (bvugt e5 e2))) +(let ((e14 (ite e10 e8 e10))) +(let ((e15 (xor e13 e11))) +(let ((e16 (xor e14 e15))) +(let ((e17 (ite e9 e12 e16))) +e17 +)))))))))))))))))) +(check-sat) diff --git a/test/regress/regress1/bvdiv2.smt2 b/test/regress/regress1/bvdiv2.smt2 new file mode 100644 index 000000000..7a8fc3753 --- /dev/null +++ b/test/regress/regress1/bvdiv2.smt2 @@ -0,0 +1,26 @@ +(set-logic QF_AUFBVLIA) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-fun x0 () (_ BitVec 10)) +(declare-fun x1 () (_ BitVec 10)) +(declare-fun x2 () (_ BitVec 10)) +(declare-fun x3 () (_ BitVec 10)) +(declare-fun x4 () (_ BitVec 10)) +(declare-fun x5 () (_ BitVec 10)) +(declare-fun x6 () (_ BitVec 10)) +(declare-fun x7 () (_ BitVec 10)) +(declare-fun x8 () (_ BitVec 10)) +(declare-fun x9 () (_ BitVec 10)) +(declare-fun v2 () Int) +(declare-fun a2 (Int) (_ BitVec 1024)) +(declare-fun v3 () (_ BitVec 1024)) +(declare-fun v4 () (_ BitVec 1024)) +(declare-fun v5 () (_ BitVec 1024)) +(assert + (and + (not (= x0 (_ bv0 10))) + (not (= (bvudiv x0 x0) (_ bv1 10))) +)) +(check-sat) +(exit) diff --git a/test/regress/regress1/constarr3.cvc b/test/regress/regress1/constarr3.cvc new file mode 100644 index 000000000..bf5cf961c --- /dev/null +++ b/test/regress/regress1/constarr3.cvc @@ -0,0 +1,12 @@ +% EXIT: 1 +% EXPECT: Array theory solver does not yet support write-chains connecting two different constant arrays +% should be unsat +all1, all2 : ARRAY INT OF INT; +aa, bb : ARRAY INT OF INT; +a, i : INT; +ASSERT all1 = ARRAY(INT OF INT) : 1; +ASSERT aa = all1 WITH [i] := 0; +ASSERT all2 = ARRAY(INT OF INT) : 2; +ASSERT bb = all2 WITH [i] := 0; +ASSERT aa = bb; +CHECKSAT; diff --git a/test/regress/regress1/constarr3.smt2 b/test/regress/regress1/constarr3.smt2 new file mode 100644 index 000000000..d514fff70 --- /dev/null +++ b/test/regress/regress1/constarr3.smt2 @@ -0,0 +1,16 @@ +; EXIT: 1 +; EXPECT: (error "Array theory solver does not yet support write-chains connecting two different constant arrays") +(set-logic QF_ALIA) +(set-info :status unsat) +(declare-const all1 (Array Int Int)) +(declare-const all2 (Array Int Int)) +(declare-const aa (Array Int Int)) +(declare-const bb (Array Int Int)) +(declare-const a Int) +(declare-const i Int) +(assert (= all1 ((as const (Array Int Int)) 1))) +(assert (= aa (store all1 i 0))) +(assert (= all2 ((as const (Array Int Int)) 2))) +(assert (= bb (store all2 i 0))) +(assert (= aa bb)) +(check-sat) diff --git a/test/regress/regress1/crash_burn_locusts.smt2 b/test/regress/regress1/crash_burn_locusts.smt2 new file mode 100644 index 000000000..313d6f79c --- /dev/null +++ b/test/regress/regress1/crash_burn_locusts.smt2 @@ -0,0 +1,29 @@ +;; This is a nasty parsing test for define-fun-rec + +(set-logic UFLIRA) +(set-info :smt-lib-version 2.5) +(define-fun-rec ( + (f ((x Int)) Int 5) ;; ok, f : Int -> Int + (g ((x Int)) Int (h 4)) ;; um, ok, so g : Int -> Int and h : Int -> Int? + (h ((x Real)) Int 4) ;; oops no we were wrong, **CRASH** +)) + +(reset) + +(set-logic UFLIRA) +(set-info :smt-lib-version 2.5) +(define-fun-rec ( + (f ((x Int)) Int (g (h 4) 5)) ;; ok, f : Int -> Int and g : Int -> X -> Int and h : Int -> X ??! What the F?! (pun intended) + (g ((x Int)) Int 5) ;; wait, now g has wrong arity?!! **BURN** + (h ((x Int)) Int 2) +)) + +(reset) + +(set-logic UFLIRA) +(set-info :smt-lib-version 2.5) +(declare-const g Int 2) +(define-fun-rec ( + (f () Int g) ;; wait, which g does this refer to?! **LOCUSTS** + (g () Int 5) +)) diff --git a/test/regress/regress1/datatypes/Makefile.am b/test/regress/regress1/datatypes/Makefile.am index a9d13f763..036b8df00 100644 --- a/test/regress/regress1/datatypes/Makefile.am +++ b/test/regress/regress1/datatypes/Makefile.am @@ -17,7 +17,11 @@ endif # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" TESTS = \ - manos-model.smt2 + manos-model.smt2 \ + acyclicity-sr-ground096.smt2 \ + dt-color-2.6.smt2 \ + dt-param-card4-unsat.smt2 \ + error.cvc EXTRA_DIST = $(TESTS) diff --git a/test/regress/regress1/datatypes/acyclicity-sr-ground096.smt2 b/test/regress/regress1/datatypes/acyclicity-sr-ground096.smt2 new file mode 100644 index 000000000..1da69b279 --- /dev/null +++ b/test/regress/regress1/datatypes/acyclicity-sr-ground096.smt2 @@ -0,0 +1,78 @@ +(set-logic QF_DT) +(set-info :status unsat) +(declare-datatypes ((T 0)) (( (f0) (f1 (proj0f1 T) (proj1f1 T) (proj2f1 T) (proj3f1 T)) (f2 (proj0f2 T) (proj1f2 T) (proj2f2 T)) (f3 (proj0f3 T) (proj1f3 T)) ))) +(declare-fun uc0 () T) +(declare-fun uc1 () T) +(declare-fun uc2 () T) +(declare-fun uc3 () T) +(declare-fun uc4 () T) +(declare-fun uc5 () T) +(declare-fun uc6 () T) +(declare-fun uc7 () T) +(declare-fun uc8 () T) +(declare-fun uc9 () T) +(declare-fun uc10 () T) +(declare-fun uc11 () T) +(declare-fun uc12 () T) +(declare-fun uc13 () T) +(declare-fun uc14 () T) +(declare-fun uc15 () T) +(declare-fun uc16 () T) +(declare-fun uc17 () T) +(declare-fun uc18 () T) +(declare-fun uc19 () T) +(declare-fun uc20 () T) +(declare-fun uc21 () T) +(declare-fun uc22 () T) +(declare-fun uc23 () T) +(declare-fun uc24 () T) +(declare-fun uc25 () T) +(declare-fun uc26 () T) +(declare-fun uc27 () T) +(declare-fun uc28 () T) +(declare-fun uc29 () T) +(declare-fun uc30 () T) +(declare-fun uc31 () T) +(declare-fun uc32 () T) +(declare-fun uc33 () T) +(declare-fun uc34 () T) +(declare-fun uc35 () T) +(declare-fun uc36 () T) +(declare-fun uc37 () T) +(declare-fun uc38 () T) +(declare-fun uc39 () T) +(declare-fun uc40 () T) +(declare-fun uc41 () T) +(declare-fun uc42 () T) +(declare-fun uc43 () T) +(declare-fun uc44 () T) +(declare-fun uc45 () T) +(declare-fun uc46 () T) +(declare-fun uc47 () T) +(declare-fun uc48 () T) +(declare-fun uc49 () T) +(declare-fun uc50 () T) +(declare-fun uc51 () T) +(declare-fun uc52 () T) +(declare-fun uc53 () T) +(declare-fun uc54 () T) +(declare-fun uc55 () T) +(declare-fun uc56 () T) +(declare-fun uc57 () T) +(declare-fun uc58 () T) +(declare-fun uc59 () T) +(declare-fun uc60 () T) +(declare-fun uc61 () T) +(declare-fun uc62 () T) +(declare-fun uc63 () T) +(declare-fun uc64 () T) +(declare-fun uc65 () T) +(declare-fun uc66 () T) +(declare-fun uc67 () T) +(declare-fun uc68 () T) +(declare-fun uc69 () T) +(declare-fun uc70 () T) +(declare-fun uc71 () T) +(declare-fun uc72 () T) +(assert (or (and (= uc0 (f2 (f2 uc1 uc1 uc1) (f1 uc1 (f3 (f1 uc1 uc1 uc1 uc1) uc1) uc1 (f1 uc1 uc1 uc1 uc1)) (f3 uc1 (f3 (f2 uc1 uc1 uc1) (f2 uc1 uc1 uc1))))) (= uc1 (f1 uc2 (f1 (f3 uc2 uc2) (f2 uc2 uc2 uc2) (f3 uc2 uc2) (f3 uc2 uc2)) uc2 (f2 uc2 (f3 uc2 uc2) (f3 uc2 uc2)))) (= uc2 (f2 (f3 uc3 uc3) (f2 (f2 uc3 uc3 uc3) uc3 (f3 uc3 uc3)) (f2 uc3 uc3 uc3))) (= uc3 (f1 uc4 (f3 (f1 uc4 uc4 uc4 uc4) uc4) (f1 uc4 uc4 uc4 uc4) (f3 uc4 uc4))) (= uc4 (f1 (f2 uc5 uc5 uc5) (f2 uc5 uc5 uc5) (f1 uc5 uc5 uc5 uc5) uc5)) (= uc5 (f3 (f2 uc6 (f3 uc6 uc6) (f2 uc6 uc6 uc6)) uc6)) (= uc6 (f3 (f2 (f2 uc7 uc7 uc7) (f1 uc7 uc7 uc7 uc7) (f3 uc7 uc7)) uc7)) (= uc7 (f1 (f1 uc8 (f2 uc8 uc8 uc8) (f3 uc8 uc8) uc8) (f3 (f1 uc8 uc8 uc8 uc8) uc8) (f1 (f1 uc8 uc8 uc8 uc8) (f3 uc8 uc8) uc8 uc8) uc8)) (= uc8 (f3 (f2 (f3 uc9 uc9) uc9 (f1 uc9 uc9 uc9 uc9)) uc9)) (= uc9 (f1 (f1 (f1 uc10 uc10 uc10 uc10) (f2 uc10 uc10 uc10) (f3 uc10 uc10) (f1 uc10 uc10 uc10 uc10)) uc10 uc10 (f3 uc10 (f2 uc10 uc10 uc10)))) (= uc10 (f2 (f2 (f3 uc11 uc11) uc11 uc11) uc11 (f2 (f1 (f3 uc11 uc11) (f3 uc11 uc11) uc11 uc11) (f3 (f3 uc11 uc11) (f1 uc11 uc11 uc11 uc11)) (f3 uc11 (f1 uc11 uc11 uc11 uc11))))) (= uc11 (f3 (f3 uc12 (f2 uc12 uc12 uc12)) uc12)) (= uc12 (f3 (f1 (f2 uc0 uc0 uc0) uc0 (f3 uc0 uc0) (f1 uc0 uc0 uc0 uc0)) (f2 (f2 uc0 uc0 uc0) (f1 uc0 uc0 uc0 (f1 uc0 uc0 uc0 uc0)) (f1 uc0 uc0 uc0 uc0))))) (and (= uc13 (f1 (f1 uc14 uc14 uc14 uc14) (f3 uc14 uc14) (f3 uc14 uc14) (f3 uc14 uc14))) (= uc14 (f3 uc15 uc15)) (= uc15 (f3 uc16 (f2 uc16 uc16 uc16))) (= uc16 (f3 (f3 uc17 uc17) uc17)) (= uc17 (f3 (f3 uc18 uc18) (f1 uc18 uc18 uc18 uc18))) (= uc18 (f3 (f3 uc19 uc19) (f3 uc19 uc19))) (= uc19 (f1 (f1 uc20 uc20 uc20 uc20) uc20 (f3 uc20 uc20) (f2 uc20 uc20 uc20))) (= uc20 (f1 (f1 uc13 (f3 uc13 uc13) uc13 uc13) (f2 uc13 uc13 uc13) (f2 uc13 (f1 uc13 uc13 uc13 uc13) (f1 uc13 uc13 uc13 uc13)) uc13))) (and (= uc21 (f3 uc22 uc22)) (= uc22 (f2 uc23 (f2 (f1 uc23 uc23 uc23 (f3 uc23 uc23)) (f2 uc23 uc23 (f1 uc23 uc23 uc23 uc23)) (f3 uc23 uc23)) (f2 (f3 (f3 uc23 uc23) (f1 uc23 uc23 uc23 uc23)) (f1 (f3 uc23 uc23) (f2 uc23 uc23 uc23) uc23 (f2 uc23 uc23 uc23)) uc23))) (= uc23 (f1 (f2 uc21 uc21 uc21) (f2 uc21 uc21 uc21) (f3 uc21 uc21) uc21))) (and (= uc24 (f3 uc25 uc25)) (= uc25 (f3 (f3 (f3 uc26 uc26) (f3 uc26 uc26)) (f1 (f3 uc26 uc26) uc26 uc26 (f2 uc26 uc26 uc26)))) (= uc26 (f1 uc27 uc27 uc27 uc27)) (= uc27 (f2 (f3 uc28 uc28) (f2 (f2 (f1 uc28 uc28 uc28 uc28) (f1 uc28 uc28 uc28 uc28) (f2 uc28 uc28 uc28)) (f3 (f3 uc28 uc28) uc28) (f3 (f3 uc28 uc28) (f2 uc28 uc28 uc28))) uc28)) (= uc28 (f1 (f3 uc29 uc29) (f1 uc29 (f1 (f1 uc29 uc29 uc29 uc29) (f1 uc29 uc29 uc29 uc29) uc29 (f1 uc29 uc29 uc29 uc29)) uc29 (f3 uc29 (f3 uc29 uc29))) (f3 (f2 uc29 uc29 uc29) (f2 uc29 uc29 uc29)) (f2 (f1 (f1 uc29 uc29 uc29 uc29) uc29 (f3 uc29 uc29) uc29) (f3 (f3 uc29 uc29) (f1 uc29 uc29 uc29 uc29)) uc29))) (= uc29 (f2 uc30 (f1 uc30 uc30 uc30 uc30) uc30)) (= uc30 (f2 (f3 uc31 uc31) (f3 uc31 uc31) uc31)) (= uc31 (f1 (f3 uc32 uc32) (f3 uc32 uc32) (f2 uc32 uc32 uc32) uc32)) (= uc32 (f1 (f1 uc33 uc33 uc33 uc33) uc33 uc33 uc33)) (= uc33 (f3 (f3 uc34 uc34) (f1 (f1 uc34 uc34 uc34 uc34) (f1 uc34 uc34 uc34 uc34) (f3 uc34 uc34) uc34))) (= uc34 (f2 uc35 (f3 uc35 uc35) (f2 uc35 uc35 uc35))) (= uc35 (f3 uc36 (f3 uc36 (f3 uc36 uc36)))) (= uc36 (f3 (f3 uc37 uc37) uc37)) (= uc37 (f1 uc38 (f3 uc38 uc38) uc38 (f1 uc38 uc38 uc38 uc38))) (= uc38 (f2 (f3 uc39 uc39) (f2 uc39 uc39 uc39) uc39)) (= uc39 (f2 (f2 (f3 uc24 (f1 uc24 uc24 uc24 uc24)) (f2 (f1 uc24 uc24 uc24 uc24) (f1 uc24 uc24 uc24 uc24) (f1 uc24 uc24 uc24 uc24)) uc24) (f1 (f3 uc24 (f1 uc24 uc24 uc24 uc24)) (f1 uc24 uc24 uc24 uc24) (f1 uc24 uc24 uc24 uc24) uc24) (f1 uc24 uc24 uc24 uc24)))) (and (= uc40 (f3 uc41 uc41)) (= uc41 (f1 uc42 uc42 uc42 uc42)) (= uc42 (f1 (f1 (f2 uc43 uc43 uc43) (f2 uc43 uc43 uc43) uc43 uc43) (f3 uc43 uc43) (f3 uc43 (f2 uc43 uc43 uc43)) uc43)) (= uc43 (f1 (f3 uc44 uc44) uc44 uc44 (f3 uc44 (f3 uc44 uc44)))) (= uc44 (f2 uc45 uc45 uc45)) (= uc45 (f3 uc46 (f3 (f3 (f1 uc46 uc46 uc46 uc46) uc46) (f1 uc46 uc46 uc46 uc46)))) (= uc46 (f3 (f1 (f3 uc47 uc47) uc47 (f1 uc47 uc47 uc47 uc47) (f2 uc47 uc47 uc47)) (f3 (f2 uc47 uc47 uc47) (f2 uc47 uc47 uc47)))) (= uc47 (f1 (f2 (f1 uc48 uc48 uc48 uc48) (f1 uc48 uc48 uc48 uc48) uc48) (f3 (f1 uc48 uc48 uc48 uc48) (f2 uc48 uc48 uc48)) uc48 uc48)) (= uc48 (f2 uc49 (f1 (f3 uc49 uc49) (f3 uc49 uc49) (f1 uc49 uc49 uc49 uc49) (f1 uc49 uc49 uc49 uc49)) (f1 (f1 uc49 uc49 uc49 uc49) (f2 uc49 uc49 uc49) uc49 (f1 (f3 uc49 uc49) (f3 uc49 uc49) (f2 uc49 uc49 uc49) (f3 uc49 uc49))))) (= uc49 (f2 uc50 uc50 (f1 (f1 (f1 uc50 uc50 uc50 uc50) uc50 uc50 uc50) (f3 uc50 uc50) uc50 uc50))) (= uc50 (f1 (f1 uc51 uc51 uc51 uc51) uc51 (f3 uc51 uc51) (f2 uc51 uc51 uc51))) (= uc51 (f1 uc52 uc52 uc52 uc52)) (= uc52 (f1 (f3 (f1 uc40 uc40 uc40 uc40) (f3 (f1 uc40 uc40 uc40 uc40) (f2 uc40 uc40 uc40))) (f1 (f2 uc40 (f2 uc40 uc40 uc40) (f2 uc40 uc40 uc40)) uc40 (f2 uc40 uc40 uc40) (f2 (f2 uc40 uc40 uc40) uc40 uc40)) (f1 uc40 uc40 uc40 uc40) (f3 (f3 (f1 uc40 uc40 uc40 uc40) (f3 uc40 uc40)) (f3 uc40 uc40))))) (and (= uc53 (f1 uc54 uc54 (f1 uc54 uc54 uc54 uc54) (f2 uc54 uc54 uc54))) (= uc54 (f1 uc55 (f2 uc55 uc55 uc55) uc55 (f2 (f3 uc55 uc55) (f2 uc55 uc55 uc55) (f1 uc55 uc55 uc55 uc55)))) (= uc55 (f2 (f1 uc56 uc56 uc56 uc56) (f1 uc56 uc56 uc56 uc56) (f3 uc56 uc56))) (= uc56 (f2 (f1 (f1 uc57 uc57 uc57 uc57) uc57 (f2 uc57 uc57 uc57) (f1 uc57 uc57 uc57 uc57)) (f1 (f1 (f2 uc57 uc57 uc57) uc57 (f1 uc57 uc57 uc57 uc57) (f1 uc57 uc57 uc57 uc57)) (f1 uc57 uc57 uc57 (f2 uc57 uc57 uc57)) uc57 (f1 uc57 uc57 uc57 uc57)) (f2 uc57 uc57 (f3 (f1 uc57 uc57 uc57 uc57) uc57)))) (= uc57 (f3 uc58 (f2 uc58 (f3 uc58 uc58) (f2 uc58 uc58 uc58)))) (= uc58 (f2 (f2 uc59 (f1 (f1 uc59 uc59 uc59 uc59) (f1 uc59 uc59 uc59 uc59) (f2 uc59 uc59 uc59) (f2 uc59 uc59 uc59)) (f3 (f3 uc59 uc59) uc59)) (f1 uc59 uc59 uc59 uc59) uc59)) (= uc59 (f3 uc60 (f2 uc60 (f3 uc60 uc60) uc60))) (= uc60 (f3 uc61 (f2 uc61 uc61 uc61))) (= uc61 (f2 (f2 (f1 uc62 uc62 uc62 uc62) uc62 (f3 uc62 uc62)) (f1 uc62 uc62 uc62 uc62) uc62)) (= uc62 (f1 uc63 (f1 uc63 uc63 uc63 (f3 uc63 uc63)) (f3 uc63 uc63) (f1 uc63 uc63 uc63 uc63))) (= uc63 (f1 (f2 uc64 uc64 uc64) (f2 uc64 uc64 uc64) uc64 uc64)) (= uc64 (f1 (f3 (f1 uc65 uc65 uc65 uc65) uc65) (f2 uc65 uc65 uc65) (f2 uc65 uc65 uc65) (f2 uc65 (f1 (f2 uc65 uc65 uc65) uc65 (f2 uc65 uc65 uc65) (f2 uc65 uc65 uc65)) (f1 uc65 uc65 uc65 uc65)))) (= uc65 (f1 uc66 uc66 uc66 uc66)) (= uc66 (f3 (f1 uc67 uc67 uc67 uc67) (f1 uc67 uc67 uc67 uc67))) (= uc67 (f1 (f2 uc68 uc68 (f1 uc68 uc68 uc68 uc68)) uc68 (f1 uc68 uc68 uc68 uc68) (f3 (f1 uc68 uc68 uc68 uc68) uc68))) (= uc68 (f1 (f1 (f3 (f3 uc69 uc69) (f3 uc69 uc69)) (f3 uc69 uc69) uc69 uc69) (f3 (f3 uc69 (f2 uc69 uc69 uc69)) uc69) (f2 (f3 (f3 uc69 uc69) (f1 uc69 uc69 uc69 uc69)) (f1 uc69 (f3 uc69 uc69) uc69 uc69) (f2 uc69 uc69 uc69)) (f1 (f1 (f1 uc69 uc69 uc69 uc69) (f1 uc69 uc69 uc69 uc69) uc69 (f1 uc69 uc69 uc69 uc69)) (f2 (f2 uc69 uc69 uc69) (f2 uc69 uc69 uc69) uc69) uc69 uc69))) (= uc69 (f3 uc70 uc70)) (= uc70 (f1 uc71 (f1 (f1 uc71 uc71 uc71 uc71) (f1 uc71 uc71 uc71 uc71) (f1 uc71 uc71 uc71 uc71) (f1 uc71 uc71 uc71 uc71)) (f2 uc71 uc71 uc71) (f3 uc71 uc71))) (= uc71 (f3 (f3 uc72 (f3 uc72 uc72)) (f3 (f3 uc72 uc72) (f1 uc72 uc72 uc72 uc72)))) (= uc72 (f1 uc53 uc53 uc53 uc53))))) +(check-sat) diff --git a/test/regress/regress1/datatypes/dt-color-2.6.smt2 b/test/regress/regress1/datatypes/dt-color-2.6.smt2 new file mode 100644 index 000000000..f6148994e --- /dev/null +++ b/test/regress/regress1/datatypes/dt-color-2.6.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --lang=smt2.6 +; EXPECT: unsat +(set-logic ALL) +(set-info :status unsat) +(declare-datatype Color ( ( red ) ( green ) ( blue ) )) + +(declare-fun a () Color) +(declare-fun b () Color) +(declare-fun c () Color) +(declare-fun d () Color) + +(assert (or (distinct a b c d) + (< (match a ((red 5) (green 3) (blue 2))) 0) + (< (match b ((red 2) (_ 1))) 0) + )) + +(check-sat) diff --git a/test/regress/regress1/datatypes/dt-param-card4-unsat.smt2 b/test/regress/regress1/datatypes/dt-param-card4-unsat.smt2 new file mode 100644 index 000000000..d403cf4ee --- /dev/null +++ b/test/regress/regress1/datatypes/dt-param-card4-unsat.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: unsat +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) +(declare-datatypes (T S) ( (Pair (pair (first T) (second S)) ) ) ) + +(declare-datatypes () ((Color (red) (blue)))) + +(declare-fun p1 () (Pair Color Color)) +(declare-fun p2 () (Pair Color Color)) +(declare-fun p3 () (Pair Color Color)) +(declare-fun p4 () (Pair Color Color)) +(declare-fun p5 () (Pair Color Color)) + +(assert (distinct p1 p2 p3 p4 p5)) +(check-sat) diff --git a/test/regress/regress1/datatypes/error.cvc b/test/regress/regress1/datatypes/error.cvc new file mode 100644 index 000000000..23e658e6c --- /dev/null +++ b/test/regress/regress1/datatypes/error.cvc @@ -0,0 +1,7 @@ +% EXPECT-ERROR: CVC4 Error: +% EXPECT-ERROR: Parse Error: foo already declared in this datatype +% EXIT: 1 + +DATATYPE single_ctor = foo(bar:REAL) | foo(bar2:REAL) END; +DATATYPE double_ctor = foo(bar:REAL) END; + diff --git a/test/regress/regress1/decision/Makefile.am b/test/regress/regress1/decision/Makefile.am index 8317536c6..102c99e01 100644 --- a/test/regress/regress1/decision/Makefile.am +++ b/test/regress/regress1/decision/Makefile.am @@ -17,9 +17,13 @@ endif # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" TESTS = \ - error3.smt + error3.smt \ + quant-symmetric_unsat_7.smt2 \ + quant-Arrays_Q1-noinfer.smt2 -EXTRA_DIST = $(TESTS) +EXTRA_DIST = $(TESTS) \ + quant-symmetric_unsat_7.smt2.expect \ + quant-Arrays_Q1-noinfer.smt2.expect # synonyms for "check" in this directory .PHONY: regress regress1 test diff --git a/test/regress/regress1/decision/quant-Arrays_Q1-noinfer.smt2 b/test/regress/regress1/decision/quant-Arrays_Q1-noinfer.smt2 new file mode 100644 index 000000000..3398f5f84 --- /dev/null +++ b/test/regress/regress1/decision/quant-Arrays_Q1-noinfer.smt2 @@ -0,0 +1,73 @@ +(set-logic AUFLIA) +(set-info :source | + Boogie/Spec# benchmarks. + This benchmark was translated by Michal Moskal. +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun InRange (Int Int) Bool) +(declare-fun o () Int) +(declare-fun q () Int) +(declare-fun int_18446744073709551615 () Int) +(declare-fun Smt.false () Int) +(declare-fun anyEqual (Int Int) Int) +(declare-fun y () Int) +(declare-fun select1 (Int Int) Int) +(declare-fun select2 (Int Int Int) Int) +(declare-fun CONCVARSYM (Int) Int) +(declare-fun divides (Int Int) Int) +(declare-fun intAtMost (Int Int) Int) +(declare-fun subtypes (Int Int) Bool) +(declare-fun store1 (Int Int Int) Int) +(declare-fun store2 (Int Int Int Int) Int) +(declare-fun B_0 () Int) +(declare-fun B_1 () Int) +(declare-fun intAtLeast (Int Int) Int) +(declare-fun int_2147483647 () Int) +(declare-fun boolOr (Int Int) Int) +(declare-fun ReallyLastGeneratedExit_correct () Int) +(declare-fun int_m9223372036854775808 () Int) +(declare-fun Smt.true () Int) +(declare-fun int_4294967295 () Int) +(declare-fun start_correct () Int) +(declare-fun B () Int) +(declare-fun F () Int) +(declare-fun G () Int) +(declare-fun boolAnd (Int Int) Int) +(declare-fun boolNot (Int) Int) +(declare-fun k_0 () Int) +(declare-fun intLess (Int Int) Int) +(declare-fun intGreater (Int Int) Int) +(declare-fun anyNeq (Int Int) Int) +(declare-fun is (Int Int) Int) +(declare-fun int_m2147483648 () Int) +(declare-fun modulo (Int Int) Int) +(declare-fun boolImplies (Int Int) Int) +(declare-fun boolIff (Int Int) Int) +(declare-fun int_9223372036854775807 () Int) +(assert true) +(assert true) +(assert (forall ((?A Int) (?i Int) (?v Int)) (= (select1 (store1 ?A ?i ?v) ?i) ?v))) +(assert (forall ((?A Int) (?i Int) (?j Int) (?v Int)) (=> (not (= ?i ?j)) (= (select1 (store1 ?A ?i ?v) ?j) (select1 ?A ?j))))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?v Int)) (= (select2 (store2 ?A ?o ?f ?v) ?o ?f) ?v))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?o ?p)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?f ?g)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolIff ?x ?y) Smt.true) (= (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolImplies ?x ?y) Smt.true) (=> (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolAnd ?x ?y) Smt.true) (and (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolOr ?x ?y) Smt.true) (or (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int)) (! (= (= (boolNot ?x) Smt.true) (not (= ?x Smt.true))) :pattern ((boolNot ?x)) ))) +(assert (forall ((?x Int) (?y Int)) (= (= (anyEqual ?x ?y) Smt.true) (= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (anyNeq ?x ?y) Smt.true) (not (= ?x ?y))) :pattern ((anyNeq ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (= (= (intLess ?x ?y) Smt.true) (< ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intAtMost ?x ?y) Smt.true) (<= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intAtLeast ?x ?y) Smt.true) (>= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intGreater ?x ?y) Smt.true) (> ?x ?y)))) +(assert (distinct Smt.false Smt.true)) +(assert (forall ((?t Int)) (! (subtypes ?t ?t) :pattern ((subtypes ?t ?t)) ))) +(assert (forall ((?t Int) (?u Int) (?v Int)) (! (=> (and (subtypes ?t ?u) (subtypes ?u ?v)) (subtypes ?t ?v)) :pattern ((subtypes ?t ?u) (subtypes ?u ?v)) ))) +(assert (forall ((?t Int) (?u Int)) (! (=> (and (subtypes ?t ?u) (subtypes ?u ?t)) (= ?t ?u)) :pattern ((subtypes ?t ?u) (subtypes ?u ?t)) ))) +(assert (let ((?v_0 (forall ((?p Int) (?f Int)) (or (= (select2 B_1 ?p ?f) (select2 B ?p ?f)) (and (= ?p o) (= ?f F))))) (?v_1 (= ReallyLastGeneratedExit_correct Smt.true)) (?v_2 (= start_correct Smt.true))) (not (=> (=> (=> true (=> (= k_0 (select2 B q G)) (=> (= B_0 (store2 B o F (+ y (select2 B o F)))) (=> (= B_1 (store2 B_0 q G k_0)) (=> (=> (=> true (and ?v_0 (=> ?v_0 (=> true true)))) ?v_1) ?v_1))))) ?v_2) ?v_2)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/decision/quant-Arrays_Q1-noinfer.smt2.expect b/test/regress/regress1/decision/quant-Arrays_Q1-noinfer.smt2.expect new file mode 100644 index 000000000..7fd1d5a98 --- /dev/null +++ b/test/regress/regress1/decision/quant-Arrays_Q1-noinfer.smt2.expect @@ -0,0 +1,2 @@ +% COMMAND-LINE: --decision=justification +% EXPECT: unsat diff --git a/test/regress/regress1/decision/quant-symmetric_unsat_7.smt2 b/test/regress/regress1/decision/quant-symmetric_unsat_7.smt2 new file mode 100644 index 000000000..6acf4a3c6 --- /dev/null +++ b/test/regress/regress1/decision/quant-symmetric_unsat_7.smt2 @@ -0,0 +1,34 @@ +(set-logic AUFLIRA) +(set-info :source | Example extracted from Peter Baumgartner's talk at CADE-21: Logical Engineering with Instance-Based Methods. + +It was translated to SMT-LIB by Leonardo de Moura |) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-fun symmetric ((Array Int (Array Int Real)) Int) Bool) +(declare-fun n () Int) +(declare-fun a0 () (Array Int (Array Int Real))) +(declare-fun e0 () Real) +(declare-fun a1 () (Array Int (Array Int Real))) +(declare-fun e1 () Real) +(declare-fun a2 () (Array Int (Array Int Real))) +(declare-fun e2 () Real) +(declare-fun a3 () (Array Int (Array Int Real))) +(declare-fun e3 () Real) +(declare-fun a4 () (Array Int (Array Int Real))) +(declare-fun e4 () Real) +(declare-fun a5 () (Array Int (Array Int Real))) +(declare-fun e5 () Real) +(declare-fun a6 () (Array Int (Array Int Real))) +(declare-fun e6 () Real) +(assert (forall ((?a (Array Int (Array Int Real))) (?n Int)) (= (symmetric ?a ?n) (forall ((?i Int) (?j Int)) (=> (and (<= 1 ?i) (<= ?i ?n) (<= 1 ?j) (<= ?j ?n)) (= (select (select ?a ?i) ?j) (select (select ?a ?j) ?i))))))) +(assert (symmetric a0 n)) +(assert (= a1 (store a0 0 (store (select a0 0) 0 e0)))) +(assert (= a2 (store a1 1 (store (select a1 1) 1 e1)))) +(assert (= a3 (store a2 2 (store (select a2 2) 2 e2)))) +(assert (= a4 (store a3 3 (store (select a3 3) 3 e3)))) +(assert (= a5 (store a4 4 (store (select a4 4) 4 e4)))) +(assert (= a6 (store a5 5 (store (select a5 5) 5 e5)))) +(assert (not (symmetric a6 n))) +(check-sat) +(exit) diff --git a/test/regress/regress1/decision/quant-symmetric_unsat_7.smt2.expect b/test/regress/regress1/decision/quant-symmetric_unsat_7.smt2.expect new file mode 100644 index 000000000..7fd1d5a98 --- /dev/null +++ b/test/regress/regress1/decision/quant-symmetric_unsat_7.smt2.expect @@ -0,0 +1,2 @@ +% COMMAND-LINE: --decision=justification +% EXPECT: unsat diff --git a/test/regress/regress1/error.cvc b/test/regress/regress1/error.cvc new file mode 100644 index 000000000..8f76c798a --- /dev/null +++ b/test/regress/regress1/error.cvc @@ -0,0 +1,7 @@ +% ERROR-SCRUBBER: sed -e '/^[[:space:]]*$/d' +% EXPECT-ERROR: CVC4 Error: +% EXPECT-ERROR: Parse Error: error.cvc:6.8: Symbol 'BOOL' not declared as a type +% EXPECT-ERROR: p : BOOL; +% EXPECT-ERROR: ^ +p : BOOL; +% EXIT: 1 diff --git a/test/regress/regress1/errorcrash.smt2 b/test/regress/regress1/errorcrash.smt2 new file mode 100644 index 000000000..6b8a0a8f3 --- /dev/null +++ b/test/regress/regress1/errorcrash.smt2 @@ -0,0 +1,9 @@ +; EXIT: 1 +; EXPECT: (error "Parse Error: errorcrash.smt2:5.29: Symbol 'Array' not declared as a type") +(set-logic QF_UF) +(declare-sort U 0) +(declare-fun x () (Array U U)) +(declare-fun y () (Array U U)) +(assert (= x y)) +(check-sat) +(get-value (x y)) diff --git a/test/regress/regress1/fmf-fun-dbu.smt2 b/test/regress/regress1/fmf-fun-dbu.smt2 new file mode 100644 index 000000000..b35c98aa9 --- /dev/null +++ b/test/regress/regress1/fmf-fun-dbu.smt2 @@ -0,0 +1,14 @@ +; COMMAND-LINE: --incremental --fmf-fun --no-check-models +(set-logic UFDTLIA) +(set-option :produce-models true) +(declare-datatypes ((List 0)) (((Nil) (Cons (Cons$head Int) (Cons$tail List))))) +(define-fun-rec all-z ((x List)) Bool (=> ((_ is Cons) x) (and (= 0 (Cons$head x)) (all-z (Cons$tail x))))) +(define-fun-rec len ((x List)) Int (ite ((_ is Nil) x) 0 (+ 1 (len (Cons$tail x))))) +(declare-fun root() List) +; EXPECT: sat +(assert (and (all-z root) (<= 1 (len root)))) +(check-sat) +; EXPECT: sat +(assert (= root (Cons 0 Nil))) +(check-sat) + diff --git a/test/regress/regress1/fmf/ALG008-1.smt2 b/test/regress/regress1/fmf/ALG008-1.smt2 new file mode 100644 index 000000000..2c3bab80d --- /dev/null +++ b/test/regress/regress1/fmf/ALG008-1.smt2 @@ -0,0 +1,72 @@ +; COMMAND-LINE: --finite-model-find +; EXPECT: sat +;%-------------------------------------------------------------------------- +;% File : ALG008-1 : TPTP v5.4.0. Released v2.2.0. +;% Domain : General Algebra +;% Problem : TC + right identity does not give RC. +;% Version : [MP96] (equality) axioms : Especial. +;% English : An algebra with a right identity satisfying the Thomsen +;% Closure (RC) condition does not necessarily satisfy the +;% Reidemeister Closure (RC) condition. + +;% Refs : [McC98] McCune (1998), Email to G. Sutcliffe +;% : [MP96] McCune & Padmanabhan (1996), Automated Deduction in Eq +;% Source : [McC98] +;% Names : TC-3 [MP96] + +;% Status : Satisfiable +;% Rating : 0.50 v5.4.0, 0.80 v5.3.0, 0.78 v5.2.0, 0.80 v5.0.0, 0.78 v4.1.0, 0.71 v4.0.1, 0.80 v4.0.0, 0.50 v3.7.0, 0.33 v3.4.0, 0.50 v3.3.0, 0.33 v3.2.0, 0.80 v3.1.0, 0.67 v2.7.0, 0.33 v2.6.0, 0.86 v2.5.0, 0.50 v2.4.0, 0.67 v2.3.0, 1.00 v2.2.1 +;% Syntax : Number of clauses : 6 ( 0 non-Horn; 5 unit; 5 RR) +;% Number of atoms : 10 ( 10 equality) +;% Maximal clause size : 5 ( 2 average) +;% Number of predicates : 1 ( 0 propositional; 2-2 arity) +;% Number of functors : 9 ( 8 constant; 0-2 arity) +;% Number of variables : 9 ( 0 singleton) +;% Maximal term depth : 2 ( 2 average) +;% SPC : CNF_SAT_RFO_EQU_NUE + +;% Comments : The smallest model has 3 elements. +;%-------------------------------------------------------------------------- +;%----Thomsen Closure (TC) condition: +(set-logic UF) +(set-info :status sat) +(declare-sort sort__smt2 0) +; functions +(declare-fun multiply__smt2_2 ( sort__smt2 sort__smt2 ) sort__smt2) +(declare-fun identity__smt2_0 ( ) sort__smt2) +(declare-fun c4__smt2_0 ( ) sort__smt2) +(declare-fun a__smt2_0 ( ) sort__smt2) +(declare-fun c3__smt2_0 ( ) sort__smt2) +(declare-fun b__smt2_0 ( ) sort__smt2) +(declare-fun c2__smt2_0 ( ) sort__smt2) +(declare-fun c1__smt2_0 ( ) sort__smt2) +(declare-fun f__smt2_0 ( ) sort__smt2) +; predicates + +; thomsen_closure axiom +(assert (forall ((?V7 sort__smt2) (?V6 sort__smt2) (?W sort__smt2) (?V sort__smt2) (?U sort__smt2) (?Z sort__smt2) (?Y sort__smt2) (?X sort__smt2)) + (or (not (= (multiply__smt2_2 ?X ?Y) ?Z)) + (not (= (multiply__smt2_2 ?U ?V) ?Z)) + (not (= (multiply__smt2_2 ?X ?W) ?V6)) + (not (= (multiply__smt2_2 ?V7 ?V) ?V6)) + (= (multiply__smt2_2 ?U ?W) (multiply__smt2_2 ?V7 ?Y)))) ) + +;%----Right identity: +; right_identity axiom +(assert (forall ((?X sort__smt2)) (= (multiply__smt2_2 ?X identity__smt2_0) ?X)) ) + +;%----Denial of Reidimeister Closure (RC) condidition. +; prove_reidimeister1 negated_conjecture +(assert (= (multiply__smt2_2 c4__smt2_0 a__smt2_0) (multiply__smt2_2 c3__smt2_0 b__smt2_0)) ) + +; prove_reidimeister2 negated_conjecture +(assert (= (multiply__smt2_2 c2__smt2_0 a__smt2_0) (multiply__smt2_2 c1__smt2_0 b__smt2_0)) ) + +; prove_reidimeister3 negated_conjecture +(assert (= (multiply__smt2_2 c4__smt2_0 f__smt2_0) (multiply__smt2_2 c3__smt2_0 identity__smt2_0)) ) + +; prove_reidimeister4 negated_conjecture +(assert (not (= (multiply__smt2_2 c2__smt2_0 f__smt2_0) (multiply__smt2_2 c1__smt2_0 identity__smt2_0))) ) + + +(check-sat) diff --git a/test/regress/regress1/fmf/ForElimination-scala-9.smt2 b/test/regress/regress1/fmf/ForElimination-scala-9.smt2 deleted file mode 100644 index e8a784fc7..000000000 --- a/test/regress/regress1/fmf/ForElimination-scala-9.smt2 +++ /dev/null @@ -1,31 +0,0 @@ -; COMMAND-LINE: --finite-model-find --uf-ss=no-minimal --lang=smt2.5 -; EXPECT: unsat -(set-logic ALL_SUPPORTED) -(declare-datatypes () ((Statement!1556 (Assign!1557 (varID!1558 (_ BitVec 32)) (expr!1559 Expression!1578)) (Block!1560 (body!1561 List!1617)) (For!1562 (init!1563 Statement!1556) (expr!1564 Expression!1578) (step!1565 Statement!1556) (body!1566 Statement!1556)) (IfThenElse!1567 (expr!1568 Expression!1578) (then!1569 Statement!1556) (elze!1570 Statement!1556)) (Print!1571 (msg!1572 (_ BitVec 32)) (varID!1573 (_ BitVec 32))) (Skip!1574) (While!1575 (expr!1576 Expression!1578) (body!1577 Statement!1556))) -(Expression!1578 (And!1579 (lhs!1580 Expression!1578) (rhs!1581 Expression!1578)) (Division!1582 (lhs!1583 Expression!1578) (rhs!1584 Expression!1578)) (Equals!1585 (lhs!1586 Expression!1578) (rhs!1587 Expression!1578)) (GreaterThan!1588 (lhs!1589 Expression!1578) (rhs!1590 Expression!1578)) (IntLiteral!1591 (value!1592 (_ BitVec 32))) (LessThan!1593 (lhs!1594 Expression!1578) (rhs!1595 Expression!1578)) (Minus!1596 (lhs!1597 Expression!1578) (rhs!1598 Expression!1578)) (Modulo!1599 (lhs!1600 Expression!1578) (rhs!1601 Expression!1578)) (Neg!1602 (expr!1603 Expression!1578)) (Not!1604 (expr!1605 Expression!1578)) (Or!1606 (lhs!1607 Expression!1578) (rhs!1608 Expression!1578)) (Plus!1609 (lhs!1610 Expression!1578) (rhs!1611 Expression!1578)) (Times!1612 (lhs!1613 Expression!1578) (rhs!1614 Expression!1578)) (Var!1615 (varID!1616 (_ BitVec 32)))) -(List!1617 (Cons!1618 (head!1619 Statement!1556) (tail!1620 List!1617)) (Nil!1621)) -)) -(declare-fun error_value!1622 () Bool) -(declare-fun ifree (Statement!1556) Bool) -(declare-fun isForFreeList!223 (List!1617) Bool) -(declare-fun error_value!1623 () List!1617) -(declare-fun efll (List!1617) List!1617) -(declare-fun efl (Statement!1556) Statement!1556) -(declare-sort I_ifree 0) -(set-info :notes "ifree_arg_0_1 is op created during fun def fmf") -(declare-fun ifree_arg_0_1 (I_ifree) Statement!1556) -(declare-sort I_isForFreeList!223 0) -(set-info :notes "isForFreeList!223_arg_0_2 is op created during fun def fmf") -(declare-fun isForFreeList!223_arg_0_2 (I_isForFreeList!223) List!1617) -(declare-sort I_efll 0) -(set-info :notes "efll_arg_0_3 is op created during fun def fmf") -(declare-fun efll_arg_0_3 (I_efll) List!1617) -(declare-sort I_efl 0) -(set-info :notes "efl_arg_0_4 is op created during fun def fmf") -(declare-fun efl_arg_0_4 (I_efl) Statement!1556) -(assert (forall ((?i I_ifree)) (and (= (ifree (ifree_arg_0_1 ?i)) (ite (is-Block!1560 (ifree_arg_0_1 ?i)) (isForFreeList!223 (body!1561 (ifree_arg_0_1 ?i))) (ite (is-IfThenElse!1567 (ifree_arg_0_1 ?i)) (and (ifree (elze!1570 (ifree_arg_0_1 ?i))) (ifree (then!1569 (ifree_arg_0_1 ?i)))) (ite (is-While!1575 (ifree_arg_0_1 ?i)) (ifree (body!1577 (ifree_arg_0_1 ?i))) (not (is-For!1562 (ifree_arg_0_1 ?i))))))) (ite (is-Block!1560 (ifree_arg_0_1 ?i)) (not (forall ((?z I_isForFreeList!223)) (not (= (isForFreeList!223_arg_0_2 ?z) (body!1561 (ifree_arg_0_1 ?i)))) )) (ite (is-IfThenElse!1567 (ifree_arg_0_1 ?i)) (and (not (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (elze!1570 (ifree_arg_0_1 ?i)))) )) (not (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (then!1569 (ifree_arg_0_1 ?i)))) ))) (ite (is-While!1575 (ifree_arg_0_1 ?i)) (not (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (body!1577 (ifree_arg_0_1 ?i)))) )) true)))) )) -(assert (forall ((?i I_isForFreeList!223)) (and (= (isForFreeList!223 (isForFreeList!223_arg_0_2 ?i)) (ite (is-Nil!1621 (isForFreeList!223_arg_0_2 ?i)) true (ite (is-Cons!1618 (isForFreeList!223_arg_0_2 ?i)) (and (isForFreeList!223 (tail!1620 (isForFreeList!223_arg_0_2 ?i))) (ifree (head!1619 (isForFreeList!223_arg_0_2 ?i)))) error_value!1622))) (ite (is-Nil!1621 (isForFreeList!223_arg_0_2 ?i)) true (ite (is-Cons!1618 (isForFreeList!223_arg_0_2 ?i)) (and (not (forall ((?z I_isForFreeList!223)) (not (= (isForFreeList!223_arg_0_2 ?z) (tail!1620 (isForFreeList!223_arg_0_2 ?i)))) )) (not (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (head!1619 (isForFreeList!223_arg_0_2 ?i)))) ))) true))) )) -(assert (forall ((?i I_efll)) (and (= (efll (efll_arg_0_3 ?i)) (ite (is-Nil!1621 (efll_arg_0_3 ?i)) Nil!1621 (ite (is-Cons!1618 (efll_arg_0_3 ?i)) (Cons!1618 (efl (head!1619 (efll_arg_0_3 ?i))) (efll (tail!1620 (efll_arg_0_3 ?i)))) error_value!1623))) (ite (is-Nil!1621 (efll_arg_0_3 ?i)) true (ite (is-Cons!1618 (efll_arg_0_3 ?i)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (head!1619 (efll_arg_0_3 ?i)))) )) (not (forall ((?z I_efll)) (not (= (efll_arg_0_3 ?z) (tail!1620 (efll_arg_0_3 ?i)))) ))) true))) )) -(assert (forall ((?i I_efl)) (and (= (efl (efl_arg_0_4 ?i)) (ite (is-Block!1560 (efl_arg_0_4 ?i)) (Block!1560 (efll (body!1561 (efl_arg_0_4 ?i)))) (ite (is-IfThenElse!1567 (efl_arg_0_4 ?i)) (IfThenElse!1567 (expr!1568 (efl_arg_0_4 ?i)) (efl (then!1569 (efl_arg_0_4 ?i))) (efl (elze!1570 (efl_arg_0_4 ?i)))) (ite (is-While!1575 (efl_arg_0_4 ?i)) (While!1575 (expr!1576 (efl_arg_0_4 ?i)) (efl (body!1577 (efl_arg_0_4 ?i)))) (ite (is-For!1562 (efl_arg_0_4 ?i)) (Block!1560 (Cons!1618 (efl (init!1563 (efl_arg_0_4 ?i))) (Cons!1618 (While!1575 (expr!1564 (efl_arg_0_4 ?i)) (Block!1560 (Cons!1618 (efl (body!1566 (efl_arg_0_4 ?i))) (Cons!1618 (efl (step!1565 (efl_arg_0_4 ?i))) Nil!1621)))) Nil!1621))) (efl_arg_0_4 ?i)))))) (ite (is-Block!1560 (efl_arg_0_4 ?i)) (not (forall ((?z I_efll)) (not (= (efll_arg_0_3 ?z) (body!1561 (efl_arg_0_4 ?i)))) )) (ite (is-IfThenElse!1567 (efl_arg_0_4 ?i)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (then!1569 (efl_arg_0_4 ?i)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (elze!1570 (efl_arg_0_4 ?i)))) ))) (ite (is-While!1575 (efl_arg_0_4 ?i)) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1577 (efl_arg_0_4 ?i)))) )) (ite (is-For!1562 (efl_arg_0_4 ?i)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (init!1563 (efl_arg_0_4 ?i)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1566 (efl_arg_0_4 ?i)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (step!1565 (efl_arg_0_4 ?i)))) ))) true))))) )) -(assert (exists ((stat!216 Statement!1556)) (not (=> (and (and (and (and (is-For!1562 stat!216) (is-For!1562 stat!216)) (and (ifree (ite (is-Block!1560 (init!1563 stat!216)) (Block!1560 (efll (body!1561 (init!1563 stat!216)))) (ite (is-IfThenElse!1567 (init!1563 stat!216)) (IfThenElse!1567 (expr!1568 (init!1563 stat!216)) (efl (then!1569 (init!1563 stat!216))) (efl (elze!1570 (init!1563 stat!216)))) (ite (is-While!1575 (init!1563 stat!216)) (While!1575 (expr!1576 (init!1563 stat!216)) (efl (body!1577 (init!1563 stat!216)))) (ite (is-For!1562 (init!1563 stat!216)) (Block!1560 (Cons!1618 (efl (init!1563 (init!1563 stat!216))) (Cons!1618 (While!1575 (expr!1564 (init!1563 stat!216)) (Block!1560 (Cons!1618 (efl (body!1566 (init!1563 stat!216))) (Cons!1618 (efl (step!1565 (init!1563 stat!216))) Nil!1621)))) Nil!1621))) (init!1563 stat!216)))))) (not (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (ite (is-Block!1560 (init!1563 stat!216)) (Block!1560 (efll (body!1561 (init!1563 stat!216)))) (ite (is-IfThenElse!1567 (init!1563 stat!216)) (IfThenElse!1567 (expr!1568 (init!1563 stat!216)) (efl (then!1569 (init!1563 stat!216))) (efl (elze!1570 (init!1563 stat!216)))) (ite (is-While!1575 (init!1563 stat!216)) (While!1575 (expr!1576 (init!1563 stat!216)) (efl (body!1577 (init!1563 stat!216)))) (ite (is-For!1562 (init!1563 stat!216)) (Block!1560 (Cons!1618 (efl (init!1563 (init!1563 stat!216))) (Cons!1618 (While!1575 (expr!1564 (init!1563 stat!216)) (Block!1560 (Cons!1618 (efl (body!1566 (init!1563 stat!216))) (Cons!1618 (efl (step!1565 (init!1563 stat!216))) Nil!1621)))) Nil!1621))) (init!1563 stat!216))))))) )) (ite (is-Block!1560 (init!1563 stat!216)) (not (forall ((?z I_efll)) (not (= (efll_arg_0_3 ?z) (body!1561 (init!1563 stat!216)))) )) (ite (is-IfThenElse!1567 (init!1563 stat!216)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (then!1569 (init!1563 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (elze!1570 (init!1563 stat!216)))) ))) (ite (is-While!1575 (init!1563 stat!216)) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1577 (init!1563 stat!216)))) )) (ite (is-For!1562 (init!1563 stat!216)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (init!1563 (init!1563 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1566 (init!1563 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (step!1565 (init!1563 stat!216)))) ))) true)))))) (and (ifree (ite (is-Block!1560 (step!1565 stat!216)) (Block!1560 (efll (body!1561 (step!1565 stat!216)))) (ite (is-IfThenElse!1567 (step!1565 stat!216)) (IfThenElse!1567 (expr!1568 (step!1565 stat!216)) (efl (then!1569 (step!1565 stat!216))) (efl (elze!1570 (step!1565 stat!216)))) (ite (is-While!1575 (step!1565 stat!216)) (While!1575 (expr!1576 (step!1565 stat!216)) (efl (body!1577 (step!1565 stat!216)))) (ite (is-For!1562 (step!1565 stat!216)) (Block!1560 (Cons!1618 (efl (init!1563 (step!1565 stat!216))) (Cons!1618 (While!1575 (expr!1564 (step!1565 stat!216)) (Block!1560 (Cons!1618 (efl (body!1566 (step!1565 stat!216))) (Cons!1618 (efl (step!1565 (step!1565 stat!216))) Nil!1621)))) Nil!1621))) (step!1565 stat!216)))))) (not (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (ite (is-Block!1560 (step!1565 stat!216)) (Block!1560 (efll (body!1561 (step!1565 stat!216)))) (ite (is-IfThenElse!1567 (step!1565 stat!216)) (IfThenElse!1567 (expr!1568 (step!1565 stat!216)) (efl (then!1569 (step!1565 stat!216))) (efl (elze!1570 (step!1565 stat!216)))) (ite (is-While!1575 (step!1565 stat!216)) (While!1575 (expr!1576 (step!1565 stat!216)) (efl (body!1577 (step!1565 stat!216)))) (ite (is-For!1562 (step!1565 stat!216)) (Block!1560 (Cons!1618 (efl (init!1563 (step!1565 stat!216))) (Cons!1618 (While!1575 (expr!1564 (step!1565 stat!216)) (Block!1560 (Cons!1618 (efl (body!1566 (step!1565 stat!216))) (Cons!1618 (efl (step!1565 (step!1565 stat!216))) Nil!1621)))) Nil!1621))) (step!1565 stat!216))))))) )) (ite (is-Block!1560 (step!1565 stat!216)) (not (forall ((?z I_efll)) (not (= (efll_arg_0_3 ?z) (body!1561 (step!1565 stat!216)))) )) (ite (is-IfThenElse!1567 (step!1565 stat!216)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (then!1569 (step!1565 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (elze!1570 (step!1565 stat!216)))) ))) (ite (is-While!1575 (step!1565 stat!216)) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1577 (step!1565 stat!216)))) )) (ite (is-For!1562 (step!1565 stat!216)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (init!1563 (step!1565 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1566 (step!1565 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (step!1565 (step!1565 stat!216)))) ))) true)))))) (and (ifree (ite (is-Block!1560 (body!1566 stat!216)) (Block!1560 (efll (body!1561 (body!1566 stat!216)))) (ite (is-IfThenElse!1567 (body!1566 stat!216)) (IfThenElse!1567 (expr!1568 (body!1566 stat!216)) (efl (then!1569 (body!1566 stat!216))) (efl (elze!1570 (body!1566 stat!216)))) (ite (is-While!1575 (body!1566 stat!216)) (While!1575 (expr!1576 (body!1566 stat!216)) (efl (body!1577 (body!1566 stat!216)))) (ite (is-For!1562 (body!1566 stat!216)) (Block!1560 (Cons!1618 (efl (init!1563 (body!1566 stat!216))) (Cons!1618 (While!1575 (expr!1564 (body!1566 stat!216)) (Block!1560 (Cons!1618 (efl (body!1566 (body!1566 stat!216))) (Cons!1618 (efl (step!1565 (body!1566 stat!216))) Nil!1621)))) Nil!1621))) (body!1566 stat!216)))))) (not (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (ite (is-Block!1560 (body!1566 stat!216)) (Block!1560 (efll (body!1561 (body!1566 stat!216)))) (ite (is-IfThenElse!1567 (body!1566 stat!216)) (IfThenElse!1567 (expr!1568 (body!1566 stat!216)) (efl (then!1569 (body!1566 stat!216))) (efl (elze!1570 (body!1566 stat!216)))) (ite (is-While!1575 (body!1566 stat!216)) (While!1575 (expr!1576 (body!1566 stat!216)) (efl (body!1577 (body!1566 stat!216)))) (ite (is-For!1562 (body!1566 stat!216)) (Block!1560 (Cons!1618 (efl (init!1563 (body!1566 stat!216))) (Cons!1618 (While!1575 (expr!1564 (body!1566 stat!216)) (Block!1560 (Cons!1618 (efl (body!1566 (body!1566 stat!216))) (Cons!1618 (efl (step!1565 (body!1566 stat!216))) Nil!1621)))) Nil!1621))) (body!1566 stat!216))))))) )) (ite (is-Block!1560 (body!1566 stat!216)) (not (forall ((?z I_efll)) (not (= (efll_arg_0_3 ?z) (body!1561 (body!1566 stat!216)))) )) (ite (is-IfThenElse!1567 (body!1566 stat!216)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (then!1569 (body!1566 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (elze!1570 (body!1566 stat!216)))) ))) (ite (is-While!1575 (body!1566 stat!216)) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1577 (body!1566 stat!216)))) )) (ite (is-For!1562 (body!1566 stat!216)) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (init!1563 (body!1566 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1566 (body!1566 stat!216)))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (step!1565 (body!1566 stat!216)))) ))) true)))))) (or (ifree (ite (is-Block!1560 stat!216) (Block!1560 (efll (body!1561 stat!216))) (ite (is-IfThenElse!1567 stat!216) (IfThenElse!1567 (expr!1568 stat!216) (efl (then!1569 stat!216)) (efl (elze!1570 stat!216))) (ite (is-While!1575 stat!216) (While!1575 (expr!1576 stat!216) (efl (body!1577 stat!216))) (ite (is-For!1562 stat!216) (Block!1560 (Cons!1618 (efl (init!1563 stat!216)) (Cons!1618 (While!1575 (expr!1564 stat!216) (Block!1560 (Cons!1618 (efl (body!1566 stat!216)) (Cons!1618 (efl (step!1565 stat!216)) Nil!1621)))) Nil!1621))) stat!216))))) (forall ((?z I_ifree)) (not (= (ifree_arg_0_1 ?z) (ite (is-Block!1560 stat!216) (Block!1560 (efll (body!1561 stat!216))) (ite (is-IfThenElse!1567 stat!216) (IfThenElse!1567 (expr!1568 stat!216) (efl (then!1569 stat!216)) (efl (elze!1570 stat!216))) (ite (is-While!1575 stat!216) (While!1575 (expr!1576 stat!216) (efl (body!1577 stat!216))) (ite (is-For!1562 stat!216) (Block!1560 (Cons!1618 (efl (init!1563 stat!216)) (Cons!1618 (While!1575 (expr!1564 stat!216) (Block!1560 (Cons!1618 (efl (body!1566 stat!216)) (Cons!1618 (efl (step!1565 stat!216)) Nil!1621)))) Nil!1621))) stat!216)))))) ) (not (ite (is-Block!1560 stat!216) (not (forall ((?z I_efll)) (not (= (efll_arg_0_3 ?z) (body!1561 stat!216))) )) (ite (is-IfThenElse!1567 stat!216) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (then!1569 stat!216))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (elze!1570 stat!216))) ))) (ite (is-While!1575 stat!216) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1577 stat!216))) )) (ite (is-For!1562 stat!216) (and (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (init!1563 stat!216))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (body!1566 stat!216))) )) (not (forall ((?z I_efl)) (not (= (efl_arg_0_4 ?z) (step!1565 stat!216))) ))) true)))))))) )) -(check-sat) diff --git a/test/regress/regress1/fmf/LeftistHeap.scala-8-ncm.smt2 b/test/regress/regress1/fmf/LeftistHeap.scala-8-ncm.smt2 new file mode 100644 index 000000000..a58e85c0d --- /dev/null +++ b/test/regress/regress1/fmf/LeftistHeap.scala-8-ncm.smt2 @@ -0,0 +1,33 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-datatypes () ((array!896 (array!896!897 (size!898 (_ BitVec 32)) (content!899 (Array (_ BitVec 32) (_ BitVec 32))))))) +(declare-datatypes () ((tuple2!900 (tuple2!900!901 (_1!902 array!896) (_2!903 (_ BitVec 32)))))) +(declare-fun error_value!904 () (_ BitVec 32)) +(declare-fun error_value!905 () (_ BitVec 32)) +(declare-fun error_value!906 () array!896) +(declare-fun error_value!907 () (_ BitVec 32)) +(declare-fun error_value!908 () array!896) +(declare-fun error_value!909 () (_ BitVec 32)) +(declare-fun while0!216 (array!896 (_ BitVec 32) array!896) tuple2!900) +(declare-fun isPositive!206 (array!896 (_ BitVec 32)) Bool) +(declare-fun rec!210 ((_ BitVec 32) array!896 (_ BitVec 32)) Bool) +(declare-fun arrayconst!910 () (Array (_ BitVec 32) (_ BitVec 32))) +(declare-sort I_while0!216 0) +(declare-fun while0!216_arg_0_1 (I_while0!216) array!896) +(declare-fun while0!216_arg_1_2 (I_while0!216) (_ BitVec 32)) +(declare-fun while0!216_arg_2_3 (I_while0!216) array!896) +(declare-sort I_isPositive!206 0) +(declare-fun isPositive!206_arg_0_4 (I_isPositive!206) array!896) +(declare-fun isPositive!206_arg_1_5 (I_isPositive!206) (_ BitVec 32)) +(declare-sort I_rec!210 0) +(declare-fun rec!210_arg_0_6 (I_rec!210) (_ BitVec 32)) +(declare-fun rec!210_arg_1_7 (I_rec!210) array!896) +(declare-fun rec!210_arg_2_8 (I_rec!210) (_ BitVec 32)) +(assert (forall ((?i I_while0!216)) (and (= (while0!216 (while0!216_arg_0_1 ?i) (while0!216_arg_1_2 ?i) (while0!216_arg_2_3 ?i)) (ite (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (while0!216 (ite (bvslt (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (select (content!899 (while0!216_arg_2_3 ?i)) (while0!216_arg_1_2 ?i)) error_value!904) (_ bv0 32)) (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_0_1 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (array!896!897 (size!898 (while0!216_arg_0_1 ?i)) (store (content!899 (while0!216_arg_0_1 ?i)) (while0!216_arg_1_2 ?i) (bvneg (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (select (content!899 (while0!216_arg_2_3 ?i)) (while0!216_arg_1_2 ?i)) error_value!905)))) error_value!906) (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_0_1 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (array!896!897 (size!898 (while0!216_arg_0_1 ?i)) (store (content!899 (while0!216_arg_0_1 ?i)) (while0!216_arg_1_2 ?i) (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (select (content!899 (while0!216_arg_2_3 ?i)) (while0!216_arg_1_2 ?i)) error_value!907))) error_value!908)) (bvadd (while0!216_arg_1_2 ?i) (_ bv1 32)) (while0!216_arg_2_3 ?i)) (tuple2!900!901 (while0!216_arg_0_1 ?i) (while0!216_arg_1_2 ?i)))) (ite (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (not (forall ((?z I_while0!216)) (not (and (= (while0!216_arg_0_1 ?z) (ite (bvslt (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (select (content!899 (while0!216_arg_2_3 ?i)) (while0!216_arg_1_2 ?i)) error_value!904) (_ bv0 32)) (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_0_1 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (array!896!897 (size!898 (while0!216_arg_0_1 ?i)) (store (content!899 (while0!216_arg_0_1 ?i)) (while0!216_arg_1_2 ?i) (bvneg (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (select (content!899 (while0!216_arg_2_3 ?i)) (while0!216_arg_1_2 ?i)) error_value!905)))) error_value!906) (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_0_1 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (array!896!897 (size!898 (while0!216_arg_0_1 ?i)) (store (content!899 (while0!216_arg_0_1 ?i)) (while0!216_arg_1_2 ?i) (ite (and (bvslt (while0!216_arg_1_2 ?i) (size!898 (while0!216_arg_2_3 ?i))) (not (bvslt (while0!216_arg_1_2 ?i) (_ bv0 32)))) (select (content!899 (while0!216_arg_2_3 ?i)) (while0!216_arg_1_2 ?i)) error_value!907))) error_value!908))) (= (while0!216_arg_1_2 ?z) (bvadd (while0!216_arg_1_2 ?i) (_ bv1 32))) (= (while0!216_arg_2_3 ?z) (while0!216_arg_2_3 ?i)))) )) true)) )) +(assert (forall ((?i I_isPositive!206)) (and (= (isPositive!206 (isPositive!206_arg_0_4 ?i) (isPositive!206_arg_1_5 ?i)) (rec!210 (_ bv0 32) (isPositive!206_arg_0_4 ?i) (isPositive!206_arg_1_5 ?i))) (not (forall ((?z I_rec!210)) (not (and (= (rec!210_arg_0_6 ?z) (_ bv0 32)) (= (rec!210_arg_1_7 ?z) (isPositive!206_arg_0_4 ?i)) (= (rec!210_arg_2_8 ?z) (isPositive!206_arg_1_5 ?i)))) ))) )) +(assert (forall ((?i I_rec!210)) (and (= (rec!210 (rec!210_arg_0_6 ?i) (rec!210_arg_1_7 ?i) (rec!210_arg_2_8 ?i)) (ite (not (bvslt (rec!210_arg_0_6 ?i) (rec!210_arg_2_8 ?i))) true (ite (bvslt (ite (and (bvslt (rec!210_arg_0_6 ?i) (size!898 (rec!210_arg_1_7 ?i))) (not (bvslt (rec!210_arg_0_6 ?i) (_ bv0 32)))) (select (content!899 (rec!210_arg_1_7 ?i)) (rec!210_arg_0_6 ?i)) error_value!909) (_ bv0 32)) false (rec!210 (bvadd (rec!210_arg_0_6 ?i) (_ bv1 32)) (rec!210_arg_1_7 ?i) (rec!210_arg_2_8 ?i))))) (ite (not (bvslt (rec!210_arg_0_6 ?i) (rec!210_arg_2_8 ?i))) true (ite (bvslt (ite (and (bvslt (rec!210_arg_0_6 ?i) (size!898 (rec!210_arg_1_7 ?i))) (not (bvslt (rec!210_arg_0_6 ?i) (_ bv0 32)))) (select (content!899 (rec!210_arg_1_7 ?i)) (rec!210_arg_0_6 ?i)) error_value!909) (_ bv0 32)) true (not (forall ((?z I_rec!210)) (not (and (= (rec!210_arg_0_6 ?z) (bvadd (rec!210_arg_0_6 ?i) (_ bv1 32))) (= (rec!210_arg_1_7 ?z) (rec!210_arg_1_7 ?i)) (= (rec!210_arg_2_8 ?z) (rec!210_arg_2_8 ?i)))) ))))) )) +(assert (not (forall ((tab!211 array!896)) (or (or (bvslt (size!898 (_1!902 (while0!216 (array!896!897 (size!898 tab!211) arrayconst!910) (_ bv0 32) tab!211))) (_ bv0 32)) (forall ((?z I_while0!216)) (not (and (= (while0!216_arg_0_1 ?z) (array!896!897 (size!898 tab!211) arrayconst!910)) (= (while0!216_arg_1_2 ?z) (_ bv0 32)) (= (while0!216_arg_2_3 ?z) tab!211))) )) (or (isPositive!206 (_1!902 (while0!216 (array!896!897 (size!898 tab!211) arrayconst!910) (_ bv0 32) tab!211)) (size!898 tab!211)) (forall ((?z I_isPositive!206)) (not (and (= (isPositive!206_arg_0_4 ?z) (_1!902 (while0!216 (array!896!897 (size!898 tab!211) arrayconst!910) (_ bv0 32) tab!211))) (= (isPositive!206_arg_1_5 ?z) (size!898 tab!211)))) ) (forall ((?z I_while0!216)) (not (and (= (while0!216_arg_0_1 ?z) (array!896!897 (size!898 tab!211) arrayconst!910)) (= (while0!216_arg_1_2 ?z) (_ bv0 32)) (= (while0!216_arg_2_3 ?z) tab!211))) ))) ))) +(check-sat) + diff --git a/test/regress/regress1/fmf/Makefile.am b/test/regress/regress1/fmf/Makefile.am index efaf535c6..dc07f6ca4 100644 --- a/test/regress/regress1/fmf/Makefile.am +++ b/test/regress/regress1/fmf/Makefile.am @@ -17,8 +17,45 @@ endif # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" TESTS = \ - ForElimination-scala-9.smt2 \ - nunchaku2309663.nun.min.smt2 + agree466.smt2 \ + ALG008-1.smt2 \ + bug0909.smt2 \ + bug764.smt2 \ + datatypes-ufinite.smt2 \ + datatypes-ufinite-nested.smt2 \ + fc-pigeonhole19.smt2 \ + fib-core.smt2 \ + fmf-bound-2dim.smt2 \ + fmf-fun-no-elim-ext-arith2.smt2 \ + fmf-strange-bounds.smt2 \ + issue916-fmf-or.smt2 \ + jasmin-cdt-crash.smt2 \ + LeftistHeap.scala-8-ncm.smt2 \ + lst-no-self-rev-exp.smt2 \ + nun-0208-to.smt2 \ + pow2-bool.smt2 \ + with-ind-104-core.smt2 \ + agree467.smt2 \ + alg202+1.smt2 \ + am-bad-model.cvc \ + bound-int-alt.smt2 \ + bug651.smt2 \ + bug723-irrelevant-funs.smt2 \ + cons-sets-bounds.smt2 \ + constr-ground-to.smt2 \ + dt-proper-model.smt2 \ + fmf-bound-int.smt2 \ + fmf-fun-no-elim-ext-arith.smt2 \ + forall_unit_data.smt2 \ + fore19-exp2-core.smt2 \ + german169.smt2 \ + german73.smt2 \ + ko-bound-set.cvc \ + loopy_coda.smt2 \ + memory_model-R_cpp-dd.cvc \ + PUZ001+1.smt2 \ + refcount24.cvc.smt2 \ + sc-crash-052316.smt2 EXTRA_DIST = $(TESTS) diff --git a/test/regress/regress1/fmf/PUZ001+1.smt2 b/test/regress/regress1/fmf/PUZ001+1.smt2 new file mode 100644 index 000000000..f3db78491 --- /dev/null +++ b/test/regress/regress1/fmf/PUZ001+1.smt2 @@ -0,0 +1,118 @@ +; COMMAND-LINE: --finite-model-find --no-check-proofs --no-check-unsat-core +; EXPECT: unsat +;%------------------------------------------------------------------------------ +;% File : PUZ001+1 : TPTP v5.4.0. Released v2.0.0. +;% Domain : Puzzles +;% Problem : Dreadbury Mansion +;% Version : Especial. +;% Theorem formulation : Reduced > Complete. +;% English : Someone who lives in Dreadbury Mansion killed Aunt Agatha. +;% Agatha, the butler, and Charles live in Dreadbury Mansion, +;% and are the only people who live therein. A killer always +;% hates his victim, and is never richer than his victim. +;% Charles hates no one that Aunt Agatha hates. Agatha hates +;% everyone except the butler. The butler hates everyone not +;% richer than Aunt Agatha. The butler hates everyone Aunt +;% Agatha hates. No one hates everyone. Agatha is not the +;% butler. Therefore : Agatha killed herself. + +;% Refs : [Pel86] Pelletier (1986), Seventy-five Problems for Testing Au +;% : [Hah94] Haehnle (1994), Email to G. Sutcliffe +;% Source : [Hah94] +;% Names : Pelletier 55 [Pel86] + +;% Status : Theorem +;% Rating : 0.07 v5.3.0, 0.19 v5.2.0, 0.00 v5.0.0, 0.08 v4.1.0, 0.13 v4.0.0, 0.12 v3.7.0, 0.14 v3.5.0, 0.00 v3.4.0, 0.08 v3.3.0, 0.11 v3.2.0, 0.22 v3.1.0, 0.17 v2.7.0, 0.00 v2.5.0, 0.33 v2.4.0, 0.33 v2.2.1, 0.00 v2.1.0 +;% Syntax : Number of formulae : 14 ( 6 unit) +;% Number of atoms : 24 ( 5 equality) +;% Maximal formula depth : 5 ( 3 average) +;% Number of connectives : 16 ( 6 ~; 2 |; 1 &) +;% ( 0 <=>; 7 =>; 0 <=; 0 <~>) +;% ( 0 ~|; 0 ~&) +;% Number of predicates : 5 ( 0 propositional; 1-2 arity) +;% Number of functors : 3 ( 3 constant; 0-0 arity) +;% Number of variables : 12 ( 0 sgn; 10 !; 2 ?) +;% Maximal term depth : 1 ( 1 average) +;% SPC : FOF_THM_RFO_SEQ + +;% Comments : Modified by Geoff Sutcliffe. +;% : Also known as "Who killed Aunt Agatha" +;%------------------------------------------------------------------------------ +;%----Problem axioms +(set-logic UF) +(set-info :status unsat) +(declare-sort sort__smt2 0) +; functions +(declare-fun agatha__smt2_0 ( ) sort__smt2) +(declare-fun butler__smt2_0 ( ) sort__smt2) +(declare-fun charles__smt2_0 ( ) sort__smt2) +; predicates +(declare-fun lives__smt2_1 ( sort__smt2 ) Bool) +(declare-fun killed__smt2_2 ( sort__smt2 sort__smt2 ) Bool) +(declare-fun hates__smt2_2 ( sort__smt2 sort__smt2 ) Bool) +(declare-fun richer__smt2_2 ( sort__smt2 sort__smt2 ) Bool) + +; pel55_1 axiom +(assert (exists ((?X sort__smt2)) + (and (lives__smt2_1 ?X) + (killed__smt2_2 ?X agatha__smt2_0)))) + +; pel55_2_1 axiom +(assert (lives__smt2_1 agatha__smt2_0)) + +; pel55_2_2 axiom +(assert (lives__smt2_1 butler__smt2_0)) + +; pel55_2_3 axiom +(assert (lives__smt2_1 charles__smt2_0)) + +; pel55_3 axiom +(assert (forall ((?X sort__smt2)) + (=> (lives__smt2_1 ?X) + (or (= ?X agatha__smt2_0) + (= ?X butler__smt2_0) + (= ?X charles__smt2_0))))) + +; pel55_4 axiom +(assert (forall ((?X sort__smt2) (?Y sort__smt2)) + (=> (killed__smt2_2 ?X ?Y) + (hates__smt2_2 ?X ?Y)))) + +; pel55_5 axiom +(assert (forall ((?X sort__smt2) (?Y sort__smt2)) + (=> (killed__smt2_2 ?X ?Y) + (not (richer__smt2_2 ?X ?Y))))) + +; pel55_6 axiom +(assert (forall ((?X sort__smt2)) + (=> (hates__smt2_2 agatha__smt2_0 ?X) + (not (hates__smt2_2 charles__smt2_0 ?X))))) + +; pel55_7 axiom +(assert (forall ((?X sort__smt2)) + (=> (not (= ?X butler__smt2_0)) + (hates__smt2_2 agatha__smt2_0 ?X)))) + +; pel55_8 axiom +(assert (forall ((?X sort__smt2)) + (=> (not (richer__smt2_2 ?X agatha__smt2_0)) + (hates__smt2_2 butler__smt2_0 ?X)))) + +; pel55_9 axiom +(assert (forall ((?X sort__smt2)) + (=> (hates__smt2_2 agatha__smt2_0 ?X) + (hates__smt2_2 butler__smt2_0 ?X)))) + +; pel55_10 axiom +(assert (forall ((?X sort__smt2)) +(exists ((?Y sort__smt2)) (not (hates__smt2_2 ?X ?Y))))) + +; pel55_11 axiom +(assert (not (= agatha__smt2_0 butler__smt2_0))) + +;----This is the conjecture with negated conjecture +; pel55 conjecture +(assert (not (killed__smt2_2 agatha__smt2_0 agatha__smt2_0))) + + +(check-sat) diff --git a/test/regress/regress1/fmf/agree466.smt2 b/test/regress/regress1/fmf/agree466.smt2 new file mode 100644 index 000000000..d17a663c6 --- /dev/null +++ b/test/regress/regress1/fmf/agree466.smt2 @@ -0,0 +1,474 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: sat +; Preamble -------------- +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-datatypes () ((UNIT (Unit)))) +(declare-datatypes () ((BOOL (Truth) (Falsity)))) + +; Decls -------------- +(declare-sort node$type 0) +(declare-sort value$type 0) +(define-sort Nodes$elem$type () node$type) +(declare-sort Nodes$t$type 0) +(declare-fun Nodes$empty () Nodes$t$type) +(declare-fun Nodes$mem (Nodes$elem$type Nodes$t$type) BOOL) +(declare-fun Nodes$add (Nodes$elem$type Nodes$t$type) Nodes$t$type) +(declare-fun Nodes$remove (Nodes$elem$type Nodes$t$type) Nodes$t$type) +(declare-fun Nodes$cardinality (Nodes$t$type) Int) +(declare-fun Nodes$union (Nodes$t$type Nodes$t$type) Nodes$t$type) +(declare-fun Nodes$disjoint (Nodes$t$type Nodes$t$type) BOOL) +;Nodes$disjoint_empty : +(assert (forall ((a Nodes$t$type)) (= (Nodes$disjoint a Nodes$empty) Truth))) +;Nodes$disjoint_comm : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (= (Nodes$disjoint a b) + (Nodes$disjoint b a)))) +;Nodes$mem_empty : +(assert (forall ((e Nodes$elem$type)) (not (= (Nodes$mem e Nodes$empty) + Truth)))) +;Nodes$mem_add : +(assert (forall ((x Nodes$elem$type) (y Nodes$elem$type) (s Nodes$t$type)) + (= (Nodes$mem x (Nodes$add y s)) (ite (or (= x y) (= (Nodes$mem x s) + Truth)) Truth + Falsity)))) +;Nodes$mem_remove : +(assert (forall ((x Nodes$elem$type) (y Nodes$elem$type) (s Nodes$t$type)) + (= (Nodes$mem x (Nodes$remove y s)) (ite (and (not (= x y)) (= + (Nodes$mem + x s) + Truth)) + Truth Falsity)))) +;Nodes$mem_union1 : +(assert (forall ((x Nodes$elem$type) (a Nodes$t$type)) (=> (= (Nodes$mem x a) + Truth) (forall + ((b Nodes$t$type)) + (= + (Nodes$mem + x (Nodes$union + a b)) + Truth))))) +;Nodes$mem_union2 : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (= (Nodes$union a b) + (Nodes$union b a)))) +;Nodes$mem_union3 : +(assert (forall ((x Nodes$elem$type) (a Nodes$t$type) (b Nodes$t$type)) + (=> (= (Nodes$mem x (Nodes$union a b)) Truth) (or (= (Nodes$mem x a) + Truth) (= (Nodes$mem + x b) + Truth))))) +;Nodes$mem_union4 : +(assert (forall ((a Nodes$t$type)) (= (Nodes$union a a) a))) +;Nodes$mem_union5 : +(assert (forall ((a Nodes$t$type)) (= (Nodes$union a Nodes$empty) a))) +;Nodes$empty_union : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (=> (= (Nodes$union a b) + Nodes$empty) + (= a Nodes$empty)))) +;Nodes$card_empty : +(assert (= (Nodes$cardinality Nodes$empty) 0)) +;Nodes$card_zero : +(assert (forall ((s Nodes$t$type)) (=> (= (Nodes$cardinality s) 0) (= + s + Nodes$empty)))) +;Nodes$card_non_negative : +(assert (forall ((s Nodes$t$type)) (>= (Nodes$cardinality s) 0))) +;Nodes$card_add : +(assert (forall ((x Nodes$elem$type) (s Nodes$t$type)) (= (Nodes$cardinality + (Nodes$add x s)) + (ite (= (Nodes$mem + x s) Truth) + (Nodes$cardinality + s) (+ (Nodes$cardinality + s) 1))))) +;Nodes$card_remove : +(assert (forall ((x Nodes$elem$type) (s Nodes$t$type)) (= (Nodes$cardinality + (Nodes$remove x s)) + (ite (= (Nodes$mem + x s) Truth) (- + (Nodes$cardinality + s) 1) (Nodes$cardinality + s))))) +;Nodes$card_union : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (=> (= (Nodes$disjoint + a b) Truth) + (= (Nodes$cardinality + (Nodes$union a b)) (+ + (Nodes$cardinality + a) (Nodes$cardinality b)))))) +(declare-fun Nodes$eq (Nodes$t$type Nodes$t$type) BOOL) +;Nodes$eq_is_equality : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (= (Nodes$eq a b) + (ite (= a b) Truth + Falsity)))) +;Nodes$equal1 : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (=> (forall ((x Nodes$elem$type)) + (= (Nodes$mem x a) + (Nodes$mem x b))) + (= (Nodes$eq a b) + Truth)))) +(define-sort Values$elem$type () value$type) +(declare-sort Values$t$type 0) +(declare-fun Values$empty () Values$t$type) +(declare-fun Values$mem (Values$elem$type Values$t$type) BOOL) +(declare-fun Values$add (Values$elem$type Values$t$type) Values$t$type) +(declare-fun Values$remove (Values$elem$type Values$t$type) Values$t$type) +(declare-fun Values$cardinality (Values$t$type) Int) +(declare-fun Values$union (Values$t$type Values$t$type) Values$t$type) +(declare-fun Values$disjoint (Values$t$type Values$t$type) BOOL) +;Values$disjoint_empty : +(assert (forall ((a Values$t$type)) (= (Values$disjoint a Values$empty) + Truth))) +;Values$disjoint_comm : +(assert (forall ((a Values$t$type) (b Values$t$type)) (= (Values$disjoint + a b) (Values$disjoint + b a)))) +;Values$mem_empty : +(assert (forall ((e Values$elem$type)) (not (= (Values$mem e Values$empty) + Truth)))) +;Values$mem_add : +(assert (forall ((x Values$elem$type) (y Values$elem$type) (s Values$t$type)) + (= (Values$mem x (Values$add y s)) (ite (or (= x y) (= (Values$mem + x s) Truth)) + Truth Falsity)))) +;Values$mem_remove : +(assert (forall ((x Values$elem$type) (y Values$elem$type) (s Values$t$type)) + (= (Values$mem x (Values$remove y s)) (ite (and (not (= x y)) + (= (Values$mem x s) + Truth)) Truth Falsity)))) +;Values$mem_union1 : +(assert (forall ((x Values$elem$type) (a Values$t$type)) (=> (= (Values$mem + x a) + Truth) (forall + ( + (b Values$t$type)) + (= + (Values$mem + x + (Values$union + a b)) + Truth))))) +;Values$mem_union2 : +(assert (forall ((a Values$t$type) (b Values$t$type)) (= (Values$union a b) + (Values$union b a)))) +;Values$mem_union3 : +(assert (forall ((x Values$elem$type) (a Values$t$type) (b Values$t$type)) + (=> (= (Values$mem x (Values$union a b)) Truth) (or (= (Values$mem + x a) Truth) + (= (Values$mem x b) + Truth))))) +;Values$mem_union4 : +(assert (forall ((a Values$t$type)) (= (Values$union a a) a))) +;Values$mem_union5 : +(assert (forall ((a Values$t$type)) (= (Values$union a Values$empty) a))) +;Values$empty_union : +(assert (forall ((a Values$t$type) (b Values$t$type)) (=> (= (Values$union + a b) Values$empty) + (= a Values$empty)))) +;Values$card_empty : +(assert (= (Values$cardinality Values$empty) 0)) +;Values$card_zero : +(assert (forall ((s Values$t$type)) (=> (= (Values$cardinality s) 0) + (= s Values$empty)))) +;Values$card_non_negative : +(assert (forall ((s Values$t$type)) (>= (Values$cardinality s) 0))) +;Values$card_add : +(assert (forall ((x Values$elem$type) (s Values$t$type)) (= (Values$cardinality + (Values$add x s)) + (ite (= (Values$mem + x s) + Truth) + (Values$cardinality + s) (+ (Values$cardinality + s) 1))))) +;Values$card_remove : +(assert (forall ((x Values$elem$type) (s Values$t$type)) (= (Values$cardinality + (Values$remove + x s)) (ite + (= + (Values$mem + x s) + Truth) (- + (Values$cardinality + s) + 1) + (Values$cardinality + s))))) +;Values$card_union : +(assert (forall ((a Values$t$type) (b Values$t$type)) (=> (= (Values$disjoint + a b) Truth) + (= (Values$cardinality + (Values$union a b)) (+ + (Values$cardinality + a) (Values$cardinality + b)))))) +(declare-fun Values$eq (Values$t$type Values$t$type) BOOL) +;Values$eq_is_equality : +(assert (forall ((a Values$t$type) (b Values$t$type)) (= (Values$eq a b) + (ite (= a b) Truth + Falsity)))) +;Values$equal1 : +(assert (forall ((a Values$t$type) (b Values$t$type)) (=> (forall ((x Values$elem$type)) + (= (Values$mem x a) + (Values$mem + x b))) (= (Values$eq + a b) + Truth)))) +(define-sort node_set$type () (Array node$type BOOL)) +(declare-fun mk_array_1 () (Array node$type BOOL)) +;mk_array_1_def : +(assert (forall ((mk_array_1_index node$type)) (= (select mk_array_1 + mk_array_1_index) Falsity))) +(define-fun empty_node_set () node_set$type mk_array_1) +(define-sort node_pair_set$type () (Array node$type (Array node$type BOOL))) +(declare-fun mk_array_2 () (Array node$type BOOL)) +;mk_array_2_def : +(assert (forall ((mk_array_2_index node$type)) (= (select mk_array_2 + mk_array_2_index) Falsity))) +(declare-fun mk_array_3 () (Array node$type (Array node$type BOOL))) +;mk_array_3_def : +(assert (forall ((mk_array_3_index node$type)) (= (select mk_array_3 + mk_array_3_index) mk_array_2))) +(define-fun empty_node_pair_set () node_pair_set$type mk_array_3) +(declare-fun mk_array_4 () (Array node$type BOOL)) +;mk_array_4_def : +(assert (forall ((mk_array_4_index node$type)) (= (select mk_array_4 + mk_array_4_index) Truth))) +(declare-fun mk_array_5 () (Array node$type (Array node$type BOOL))) +;mk_array_5_def : +(assert (forall ((mk_array_5_index node$type)) (= (select mk_array_5 + mk_array_5_index) mk_array_4))) +(define-fun full_node_pair_set () node_pair_set$type mk_array_5) +(declare-fun input () (Array node$type value$type)) +(declare-fun t () Int) +;positive_bound : +(assert (> t 0)) +(define-sort message$type () Values$t$type) +(define-sort message_set$type () (Array node$type message$type)) +(define-sort state$type () Values$t$type) +(define-sort state_set$type () (Array node$type state$type)) +(define-fun null_message () message$type Values$empty) +(declare-fun mk_array_6 () (Array node$type message$type)) +;mk_array_6_def : +(assert (forall ((mk_array_6_index node$type)) (= (select mk_array_6 + mk_array_6_index) null_message))) +(define-fun null_message_set () message_set$type mk_array_6) +(define-fun null_state () state$type Values$empty) +(declare-fun mk_array_7 () (Array node$type state$type)) +;mk_array_7_def : +(assert (forall ((mk_array_7_index node$type)) (= (select mk_array_7 + mk_array_7_index) null_state))) +(define-fun null_state_set () state_set$type mk_array_7) +(declare-fun choose (Values$t$type) value$type) +;choosen_value : +(assert (forall ((vals Values$t$type)) (or (= vals Values$empty) (= (Values$mem + (choose + vals) + vals) + Truth)))) +(define-sort failure_pattern$type () node_pair_set$type) +(define-fun is_faulty ((p node$type) (deliver failure_pattern$type)) BOOL +(ite (exists ((q node$type)) (not (= (select (select deliver p) q) Truth))) +Truth Falsity)) +(define-fun is_silent ((p node$type) (deliver failure_pattern$type)) BOOL +(ite (forall ((q node$type)) (not (= (select (select deliver p) q) Truth))) +Truth Falsity)) +(declare-datatypes () ((phase_state$type (init_phase) (send_phase) (recv_phase) (comp_phase)))) +(declare-datatypes () ((clean_state$type (before) (active) (after)))) + +; Var Decls -------------- +(declare-fun my_compute$result$1 () state$type) +(declare-fun output$1 () (Array node$type value$type)) +(declare-fun comp_done () node_set$type) +(declare-fun compute$can_decide$0$1 () BOOL) +(declare-fun chosen () (Array node$type BOOL)) +(declare-fun recv_done () node_pair_set$type) +(declare-fun output () (Array node$type value$type)) +(declare-fun phase () phase_state$type) +(declare-fun global_state () state_set$type) +(declare-fun my_decide$result$1 () value$type) +(declare-fun round () Int) +(declare-fun compute$n () node$type) +(declare-fun send_done () node_pair_set$type) +(declare-fun my_can_decide$result$1 () BOOL) +(declare-fun chosen$1 () (Array node$type BOOL)) +(declare-fun comp_done$1 () node_set$type) +(declare-fun global_state$1 () state_set$type) + +; Asserts -------------- +(assert (not (=> (forall ((n node$type)) (=> + (and + (= + (select + chosen + n) + Truth) + (= + round (+ + t + 1))) + (and + (forall + ( + (n node$type) (m node$type)) + (= + (select + (select + send_done + n) + m) + Truth)) + (forall + ( + (n node$type) (m node$type)) + (= + (select + (select + recv_done + n) + m) + Truth))))) + (=> (= phase comp_phase) (=> + (not + (= (select + comp_done + compute$n) + Truth)) + (=> + (= my_compute$result$1 + (select + global_state + compute$n)) + (=> + (= global_state$1 + (store + global_state + compute$n + my_compute$result$1)) + (=> + (= my_can_decide$result$1 + (ite + (= round (+ + t 1)) + Truth + Falsity)) + (=> + (= compute$can_decide$0$1 + my_can_decide$result$1) + (= (ite + (= + compute$can_decide$0$1 + Truth) + (ite + (=> + (= + my_decide$result$1 + (choose + (select + global_state$1 + compute$n))) + (=> + (= + output$1 + (store + output + compute$n + my_decide$result$1)) + (=> + (= + chosen$1 + (store + chosen + compute$n + Truth)) + (=> + (= + comp_done$1 + (store + comp_done + compute$n + Truth)) + (forall + ( + (n node$type)) + (=> + (and + (= + (select + chosen$1 + n) + Truth) + (= + round (+ + t + 1))) + (and + (forall + ( + (n node$type) (m node$type)) + (= + (select + (select + send_done + n) + m) + Truth)) + (forall + ( + (n node$type) (m node$type)) + (= + (select + (select + recv_done + n) + m) + Truth))))))))) + Truth + Falsity) + (ite + (=> + (= + comp_done$1 + (store + comp_done + compute$n + Truth)) + (forall + ( + (n node$type)) + (=> + (and + (= + (select + chosen + n) + Truth) + (= + round (+ + t + 1))) + (and + (forall + ( + (n node$type) (m node$type)) + (= + (select + (select + send_done + n) + m) + Truth)) + (forall + ( + (n node$type) (m node$type)) + (= + (select + (select + recv_done + n) + m) + Truth)))))) + Truth + Falsity)) + Truth)))))))))) + +(check-sat) diff --git a/test/regress/regress1/fmf/agree467.smt2 b/test/regress/regress1/fmf/agree467.smt2 new file mode 100644 index 000000000..07180cf4f --- /dev/null +++ b/test/regress/regress1/fmf/agree467.smt2 @@ -0,0 +1,341 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: unsat +; Preamble -------------- +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-datatypes () ((UNIT (Unit)))) +(declare-datatypes () ((BOOL (Truth) (Falsity)))) + +; Decls -------------- +(declare-sort node$type 0) +(declare-sort value$type 0) +(define-sort Nodes$elem$type () node$type) +(declare-sort Nodes$t$type 0) +(declare-fun Nodes$empty () Nodes$t$type) +(declare-fun Nodes$mem (Nodes$elem$type Nodes$t$type) BOOL) +(declare-fun Nodes$add (Nodes$elem$type Nodes$t$type) Nodes$t$type) +(declare-fun Nodes$remove (Nodes$elem$type Nodes$t$type) Nodes$t$type) +(declare-fun Nodes$cardinality (Nodes$t$type) Int) +(declare-fun Nodes$union (Nodes$t$type Nodes$t$type) Nodes$t$type) +(declare-fun Nodes$disjoint (Nodes$t$type Nodes$t$type) BOOL) +;Nodes$disjoint_empty : +(assert (forall ((a Nodes$t$type)) (= (Nodes$disjoint a Nodes$empty) Truth))) +;Nodes$disjoint_comm : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (= (Nodes$disjoint a b) + (Nodes$disjoint b a)))) +;Nodes$mem_empty : +(assert (forall ((e Nodes$elem$type)) (not (= (Nodes$mem e Nodes$empty) + Truth)))) +;Nodes$mem_add : +(assert (forall ((x Nodes$elem$type) (y Nodes$elem$type) (s Nodes$t$type)) + (= (Nodes$mem x (Nodes$add y s)) (ite (or (= x y) (= (Nodes$mem x s) + Truth)) Truth + Falsity)))) +;Nodes$mem_remove : +(assert (forall ((x Nodes$elem$type) (y Nodes$elem$type) (s Nodes$t$type)) + (= (Nodes$mem x (Nodes$remove y s)) (ite (and (not (= x y)) (= + (Nodes$mem + x s) + Truth)) + Truth Falsity)))) +;Nodes$mem_union1 : +(assert (forall ((x Nodes$elem$type) (a Nodes$t$type)) (=> (= (Nodes$mem x a) + Truth) (forall + ((b Nodes$t$type)) + (= + (Nodes$mem + x (Nodes$union + a b)) + Truth))))) +;Nodes$mem_union2 : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (= (Nodes$union a b) + (Nodes$union b a)))) +;Nodes$mem_union3 : +(assert (forall ((x Nodes$elem$type) (a Nodes$t$type) (b Nodes$t$type)) + (=> (= (Nodes$mem x (Nodes$union a b)) Truth) (or (= (Nodes$mem x a) + Truth) (= (Nodes$mem + x b) + Truth))))) +;Nodes$mem_union4 : +(assert (forall ((a Nodes$t$type)) (= (Nodes$union a a) a))) +;Nodes$mem_union5 : +(assert (forall ((a Nodes$t$type)) (= (Nodes$union a Nodes$empty) a))) +;Nodes$empty_union : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (=> (= (Nodes$union a b) + Nodes$empty) + (= a Nodes$empty)))) +;Nodes$card_empty : +(assert (= (Nodes$cardinality Nodes$empty) 0)) +;Nodes$card_zero : +(assert (forall ((s Nodes$t$type)) (=> (= (Nodes$cardinality s) 0) (= + s + Nodes$empty)))) +;Nodes$card_non_negative : +(assert (forall ((s Nodes$t$type)) (>= (Nodes$cardinality s) 0))) +;Nodes$card_add : +(assert (forall ((x Nodes$elem$type) (s Nodes$t$type)) (= (Nodes$cardinality + (Nodes$add x s)) + (ite (= (Nodes$mem + x s) Truth) + (Nodes$cardinality + s) (+ (Nodes$cardinality + s) 1))))) +;Nodes$card_remove : +(assert (forall ((x Nodes$elem$type) (s Nodes$t$type)) (= (Nodes$cardinality + (Nodes$remove x s)) + (ite (= (Nodes$mem + x s) Truth) (- + (Nodes$cardinality + s) 1) (Nodes$cardinality + s))))) +;Nodes$card_union : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (=> (= (Nodes$disjoint + a b) Truth) + (= (Nodes$cardinality + (Nodes$union a b)) (+ + (Nodes$cardinality + a) (Nodes$cardinality b)))))) +(declare-fun Nodes$eq (Nodes$t$type Nodes$t$type) BOOL) +;Nodes$eq_is_equality : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (= (Nodes$eq a b) + (ite (= a b) Truth + Falsity)))) +;Nodes$equal1 : +(assert (forall ((a Nodes$t$type) (b Nodes$t$type)) (=> (forall ((x Nodes$elem$type)) + (= (Nodes$mem x a) + (Nodes$mem x b))) + (= (Nodes$eq a b) + Truth)))) +(define-sort Values$elem$type () value$type) +(declare-sort Values$t$type 0) +(declare-fun Values$empty () Values$t$type) +(declare-fun Values$mem (Values$elem$type Values$t$type) BOOL) +(declare-fun Values$add (Values$elem$type Values$t$type) Values$t$type) +(declare-fun Values$remove (Values$elem$type Values$t$type) Values$t$type) +(declare-fun Values$cardinality (Values$t$type) Int) +(declare-fun Values$union (Values$t$type Values$t$type) Values$t$type) +(declare-fun Values$disjoint (Values$t$type Values$t$type) BOOL) +;Values$disjoint_empty : +(assert (forall ((a Values$t$type)) (= (Values$disjoint a Values$empty) + Truth))) +;Values$disjoint_comm : +(assert (forall ((a Values$t$type) (b Values$t$type)) (= (Values$disjoint + a b) (Values$disjoint + b a)))) +;Values$mem_empty : +(assert (forall ((e Values$elem$type)) (not (= (Values$mem e Values$empty) + Truth)))) +;Values$mem_add : +(assert (forall ((x Values$elem$type) (y Values$elem$type) (s Values$t$type)) + (= (Values$mem x (Values$add y s)) (ite (or (= x y) (= (Values$mem + x s) Truth)) + Truth Falsity)))) +;Values$mem_remove : +(assert (forall ((x Values$elem$type) (y Values$elem$type) (s Values$t$type)) + (= (Values$mem x (Values$remove y s)) (ite (and (not (= x y)) + (= (Values$mem x s) + Truth)) Truth Falsity)))) +;Values$mem_union1 : +(assert (forall ((x Values$elem$type) (a Values$t$type)) (=> (= (Values$mem + x a) + Truth) (forall + ( + (b Values$t$type)) + (= + (Values$mem + x + (Values$union + a b)) + Truth))))) +;Values$mem_union2 : +(assert (forall ((a Values$t$type) (b Values$t$type)) (= (Values$union a b) + (Values$union b a)))) +;Values$mem_union3 : +(assert (forall ((x Values$elem$type) (a Values$t$type) (b Values$t$type)) + (=> (= (Values$mem x (Values$union a b)) Truth) (or (= (Values$mem + x a) Truth) + (= (Values$mem x b) + Truth))))) +;Values$mem_union4 : +(assert (forall ((a Values$t$type)) (= (Values$union a a) a))) +;Values$mem_union5 : +(assert (forall ((a Values$t$type)) (= (Values$union a Values$empty) a))) +;Values$empty_union : +(assert (forall ((a Values$t$type) (b Values$t$type)) (=> (= (Values$union + a b) Values$empty) + (= a Values$empty)))) +;Values$card_empty : +(assert (= (Values$cardinality Values$empty) 0)) +;Values$card_zero : +(assert (forall ((s Values$t$type)) (=> (= (Values$cardinality s) 0) + (= s Values$empty)))) +;Values$card_non_negative : +(assert (forall ((s Values$t$type)) (>= (Values$cardinality s) 0))) +;Values$card_add : +(assert (forall ((x Values$elem$type) (s Values$t$type)) (= (Values$cardinality + (Values$add x s)) + (ite (= (Values$mem + x s) + Truth) + (Values$cardinality + s) (+ (Values$cardinality + s) 1))))) +;Values$card_remove : +(assert (forall ((x Values$elem$type) (s Values$t$type)) (= (Values$cardinality + (Values$remove + x s)) (ite + (= + (Values$mem + x s) + Truth) (- + (Values$cardinality + s) + 1) + (Values$cardinality + s))))) +;Values$card_union : +(assert (forall ((a Values$t$type) (b Values$t$type)) (=> (= (Values$disjoint + a b) Truth) + (= (Values$cardinality + (Values$union a b)) (+ + (Values$cardinality + a) (Values$cardinality + b)))))) +(declare-fun Values$eq (Values$t$type Values$t$type) BOOL) +;Values$eq_is_equality : +(assert (forall ((a Values$t$type) (b Values$t$type)) (= (Values$eq a b) + (ite (= a b) Truth + Falsity)))) +;Values$equal1 : +(assert (forall ((a Values$t$type) (b Values$t$type)) (=> (forall ((x Values$elem$type)) + (= (Values$mem x a) + (Values$mem + x b))) (= (Values$eq + a b) + Truth)))) +(define-sort node_set$type () (Array node$type BOOL)) +(declare-fun mk_array_1 () (Array node$type BOOL)) +;mk_array_1_def : +(assert (forall ((mk_array_1_index node$type)) (= (select mk_array_1 + mk_array_1_index) Falsity))) +(define-fun empty_node_set () node_set$type mk_array_1) +(define-sort node_pair_set$type () (Array node$type (Array node$type BOOL))) +(declare-fun mk_array_2 () (Array node$type BOOL)) +;mk_array_2_def : +(assert (forall ((mk_array_2_index node$type)) (= (select mk_array_2 + mk_array_2_index) Falsity))) +(declare-fun mk_array_3 () (Array node$type (Array node$type BOOL))) +;mk_array_3_def : +(assert (forall ((mk_array_3_index node$type)) (= (select mk_array_3 + mk_array_3_index) mk_array_2))) +(define-fun empty_node_pair_set () node_pair_set$type mk_array_3) +(declare-fun mk_array_4 () (Array node$type BOOL)) +;mk_array_4_def : +(assert (forall ((mk_array_4_index node$type)) (= (select mk_array_4 + mk_array_4_index) Truth))) +(declare-fun mk_array_5 () (Array node$type (Array node$type BOOL))) +;mk_array_5_def : +(assert (forall ((mk_array_5_index node$type)) (= (select mk_array_5 + mk_array_5_index) mk_array_4))) +(define-fun full_node_pair_set () node_pair_set$type mk_array_5) +(declare-fun input () (Array node$type value$type)) +(declare-fun t () Int) +;positive_bound : +(assert (> t 0)) +(define-sort message$type () Values$t$type) +(define-sort message_set$type () (Array node$type message$type)) +(define-sort state$type () Values$t$type) +(define-sort state_set$type () (Array node$type state$type)) +(define-fun null_message () message$type Values$empty) +(declare-fun mk_array_6 () (Array node$type message$type)) +;mk_array_6_def : +(assert (forall ((mk_array_6_index node$type)) (= (select mk_array_6 + mk_array_6_index) null_message))) +(define-fun null_message_set () message_set$type mk_array_6) +(define-fun null_state () state$type Values$empty) +(declare-fun mk_array_7 () (Array node$type state$type)) +;mk_array_7_def : +(assert (forall ((mk_array_7_index node$type)) (= (select mk_array_7 + mk_array_7_index) null_state))) +(define-fun null_state_set () state_set$type mk_array_7) +(declare-fun choose (Values$t$type) value$type) +;choosen_value : +(assert (forall ((vals Values$t$type)) (or (= vals Values$empty) (= (Values$mem + (choose + vals) + vals) + Truth)))) +(define-sort failure_pattern$type () node_pair_set$type) +(define-fun is_faulty ((p node$type) (deliver failure_pattern$type)) BOOL +(ite (exists ((q node$type)) (not (= (select (select deliver p) q) Truth))) +Truth Falsity)) +(define-fun is_silent ((p node$type) (deliver failure_pattern$type)) BOOL +(ite (forall ((q node$type)) (not (= (select (select deliver p) q) Truth))) +Truth Falsity)) +(declare-datatypes () ((phase_state$type (init_phase) (send_phase) (recv_phase) (comp_phase)))) +(declare-datatypes () ((clean_state$type (before) (active) (after)))) + +; Var Decls -------------- +(declare-fun init_done () node_set$type) +(declare-fun crashed () Nodes$t$type) +(declare-fun comp_done () node_set$type) +(declare-fun chosen () (Array node$type BOOL)) +(declare-fun recv_done () node_pair_set$type) +(declare-fun phase () phase_state$type) +(declare-fun clean () clean_state$type) +(declare-fun global_state () state_set$type) +(declare-fun messages () (Array node$type message_set$type)) +(declare-fun deliver_message () failure_pattern$type) +(declare-fun crashing () Nodes$t$type) +(declare-fun round () Int) +(declare-fun send_done () node_pair_set$type) + +; Asserts -------------- +(declare-fun mk_array_8 () (Array node$type BOOL)) +;mk_array_8_def : +(assert (forall ((mk_array_8_index node$type)) (= (select mk_array_8 + mk_array_8_index) Falsity))) +(declare-fun mk_array_9 () (Array node$type message_set$type)) +;mk_array_9_def : +(assert (forall ((mk_array_9_index node$type)) (= (select mk_array_9 + mk_array_9_index) null_message_set))) +(assert (not (=> (and (and (and (and (and (and (and (and (and (and (and + (and + (= + clean + before) + (= + global_state + null_state_set)) + (= + messages + mk_array_9)) + (= deliver_message + full_node_pair_set)) + (= comp_done + empty_node_set)) + (= recv_done empty_node_pair_set)) + (= send_done empty_node_pair_set)) + (= init_done empty_node_set)) + (= phase init_phase)) (= crashing + Nodes$empty)) + (= crashed Nodes$empty)) (= round 0)) (= chosen + mk_array_8)) + (forall ((n node$type)) (=> (and (= (select chosen n) Truth) + (= round (+ t 1))) (and (forall + ((n node$type) (m node$type)) + (= (select + (select + send_done + n) + m) + Truth)) + (forall ( + (n node$type) (m node$type)) + (= (select + (select + recv_done + n) m) + Truth)))))))) + +(check-sat) diff --git a/test/regress/regress1/fmf/alg202+1.smt2 b/test/regress/regress1/fmf/alg202+1.smt2 new file mode 100644 index 000000000..ff3460636 --- /dev/null +++ b/test/regress/regress1/fmf/alg202+1.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --finite-model-find +; EXPECT: unsat +(set-logic ALL) +(declare-sort $$unsorted 0) +(declare-fun sorti1 ($$unsorted) Bool) +(declare-fun op1 ($$unsorted $$unsorted) $$unsorted) +(declare-fun sorti2 ($$unsorted) Bool) +(declare-fun op2 ($$unsorted $$unsorted) $$unsorted) +(declare-fun h ($$unsorted) $$unsorted) +(declare-fun j ($$unsorted) $$unsorted) +(assert (forall ((U $$unsorted) (BOUND_VARIABLE_345 $$unsorted)) (or (not (sorti1 U)) (not (sorti1 BOUND_VARIABLE_345)) (sorti1 (op1 U BOUND_VARIABLE_345))) )) +(assert (forall ((U $$unsorted) (BOUND_VARIABLE_364 $$unsorted)) (or (not (sorti2 U)) (not (sorti2 BOUND_VARIABLE_364)) (sorti2 (op2 U BOUND_VARIABLE_364))) )) +(assert (forall ((U $$unsorted)) (or (not (sorti1 U)) (= U (op1 U U))) )) +(assert (not (forall ((U $$unsorted)) (or (not (sorti2 U)) (= U (op2 U U))) ))) +(assert (not (=> (and (forall ((U $$unsorted)) (or (not (sorti1 U)) (sorti2 (h U))) ) (forall ((V $$unsorted)) (or (not (sorti2 V)) (sorti1 (j V))) )) (not (and (forall ((W $$unsorted) (BOUND_VARIABLE_406 $$unsorted)) (or (not (sorti1 W)) (not (sorti1 BOUND_VARIABLE_406)) (= (op2 (h W) (h BOUND_VARIABLE_406)) (h (op1 W BOUND_VARIABLE_406)))) ) (forall ((Y $$unsorted) (BOUND_VARIABLE_431 $$unsorted)) (or (not (sorti2 Y)) (not (sorti2 BOUND_VARIABLE_431)) (= (op1 (j Y) (j BOUND_VARIABLE_431)) (j (op2 Y BOUND_VARIABLE_431)))) ) (forall ((X1 $$unsorted)) (or (not (sorti2 X1)) (= X1 (h (j X1)))) ) (forall ((X2 $$unsorted)) (or (not (sorti1 X2)) (= X2 (j (h X2)))) )))))) +(assert (and (forall ((U $$unsorted)) (or (not (sorti1 U)) (sorti2 (h U))) ) (forall ((V $$unsorted)) (or (not (sorti2 V)) (sorti1 (j V))) ) (forall ((W $$unsorted) (BOUND_VARIABLE_406 $$unsorted)) (or (not (sorti1 W)) (not (sorti1 BOUND_VARIABLE_406)) (= (op2 (h W) (h BOUND_VARIABLE_406)) (h (op1 W BOUND_VARIABLE_406)))) ) (forall ((Y $$unsorted) (BOUND_VARIABLE_431 $$unsorted)) (or (not (sorti2 Y)) (not (sorti2 BOUND_VARIABLE_431)) (= (op1 (j Y) (j BOUND_VARIABLE_431)) (j (op2 Y BOUND_VARIABLE_431)))) ) (forall ((X1 $$unsorted)) (or (not (sorti2 X1)) (= X1 (h (j X1)))) ) (forall ((X2 $$unsorted)) (or (not (sorti1 X2)) (= X2 (j (h X2)))) ))) +(check-sat) diff --git a/test/regress/regress1/fmf/am-bad-model.cvc b/test/regress/regress1/fmf/am-bad-model.cvc new file mode 100644 index 000000000..e30b5e04a --- /dev/null +++ b/test/regress/regress1/fmf/am-bad-model.cvc @@ -0,0 +1,22 @@ +% EXPECT: sat +OPTION "produce-models"; +OPTION "finite-model-find"; + +f : (BITVECTOR(2),BITVECTOR(2)) ->ARRAY INT OF INT; +f0 : BITVECTOR(2) -> ARRAY INT OF INT; + +td,td1,td2: ARRAY INT OF INT; +ASSERT td1 = td WITH[0]:= 1; +ASSERT td2 = td WITH[0]:= 2; +ASSERT f(0bin01,0bin00)=td1; +ASSERT f(0bin10,0bin00)=td2; +%ASSERT FORALL(i:BITVECTOR(2)) : f0(i)=f(0bin00,i) ; +%Artificial bypass of quantifier for f0 definition +ASSERT f0(0bin00) = f(0bin00,0bin00); +ASSERT f0(0bin01) = f(0bin00,0bin01); +ASSERT f0(0bin10) = f(0bin00,0bin10); +ASSERT f0(0bin11) = f(0bin00,0bin11); +ASSERT FORALL(i:BITVECTOR(2)) : f0(i)=td2 ; + +CHECKSAT; + diff --git a/test/regress/regress1/fmf/bound-int-alt.smt2 b/test/regress/regress1/fmf/bound-int-alt.smt2 new file mode 100644 index 000000000..146487925 --- /dev/null +++ b/test/regress/regress1/fmf/bound-int-alt.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --fmf-bound-int +; EXPECT: sat +(set-logic UFLIA) +(set-info :status sat) +(declare-sort U 0) +(declare-sort V 0) +(declare-fun P (U Int V Int U Int) Bool) + +(assert (forall ((x U) (y Int) (z V) (w Int) (v U) (d Int)) (=> (and (<= 0 d 1) (<= 2 y 6) (<= 40 w (+ 37 y))) (P x y z w v d)))) + +(declare-fun a () U) +(declare-fun b () V) + +(assert (not (P a 2 b 40 a 0))) +(assert (not (P a 6 b 39 a 0))) +(assert (not (P a 6 b 44 a 0))) + +(check-sat) diff --git a/test/regress/regress1/fmf/bug0909.smt2 b/test/regress/regress1/fmf/bug0909.smt2 new file mode 100644 index 000000000..fc3054c0d --- /dev/null +++ b/test/regress/regress1/fmf/bug0909.smt2 @@ -0,0 +1,54 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: unsat +; Preamble -------------- +(set-option :produce-models true) +(set-logic ALL_SUPPORTED) +;(declare-datatypes () ((x2 (x1)))) +(declare-datatypes () ((x5 (x3) (x4)))) +(declare-sort x6 0) +(declare-fun x7 (x6) x5) +(declare-fun x8 () x6) +(assert (not (= x3 (x7 x8)))) +(declare-fun x9 () x6) +(assert (not (= x3 (x7 x9)))) +(declare-fun x11 () Int) +(declare-sort x12 0) +(declare-fun x13 () x12) +(declare-datatypes () ((x17 (x14) (x15) (x16)))) +(declare-datatypes () ((x22 (x21 (x18 Int) (x19 Int) (x20 x5))))) +(declare-datatypes () ((x29 (x28 (x23 x5) (x24 x5) (x25 Int) (x26 Int) (x27 Int))))) +(declare-sort x30 0) +(declare-sort x31 0) +(declare-fun x32 () x31) +(declare-datatypes () ((x36 (x35 (x33 Int) (x34 Int))))) +(declare-fun x37 () x36) +(declare-datatypes () ((x45 (x44 (x38 x5) (x39 x6) (x40 x6) (x41 x6) (x42 x36) (x43 x31))))) +(declare-fun x47 (x12) x31) +(declare-fun x46 (x31) x12) +(declare-datatypes () ((x54 (x49 (x48 x22)) (x51 (x50 x29)) (d53 (s52 x12))))) +(declare-fun x57 (x22) x29) +(declare-fun x56 (x12) x22) +(declare-fun x55 (x29) x22) +(declare-fun x61 () (Array x6 x5)) +(declare-fun x66 () (Array x6 x17)) +(declare-fun x64 () (Array x6 x54)) +(declare-fun x67 () (Array x6 x54)) +(declare-fun x65 () (Array x6 x54)) +(declare-fun x62 () (Array x30 x45)) +(declare-fun x70 () (Array x30 x45)) +(declare-fun x68 () (Array x30 x45)) +(declare-fun x63 () x30) +(declare-fun x59 (x22) x12) +(declare-fun x60 (x29) x12) +(declare-fun x58 (x12) x29) +(declare-fun x71 () x6) +(declare-fun x69 () x6) +(assert +(not + (=> (and + (forall ((x73 x30)) (=> (= x3 (x38 (select x62 x73))) (and (= (select x66 (x40 (select x62 x73))) x15) (= x3 (x7 (x40 (select x62 x73)))) (= (select x61 (x40 (select x62 x73))) x3) (= (x23 (ite (is-x49 (select x67 (x40 (select x62 x73)))) (let ((x74 (x48 (select x67 (x40 (select x62 x73)))))) (x57 x74)) (ite (is-x51 (select x67 (x40 (select x62 x73)))) (let ((x75 (x50 (select x67 (x40 (select x62 x73)))))) x75) (let ((x76 (s52 (select x67 (x40 (select x62 x73)))))) (x58 x76))))) x3)))) + (forall ((x72 x6)) (=> (and (= x16 (select x66 x72)) (= (x7 x72) x3) (= (select x61 x72) x3)) (= (ite (is-d53 (select x67 x72)) x3 x4) x3)))) + + (= (ite (= (x38 (select x62 x63)) x3) (ite (and (=> (= (x40 (select x62 x63)) x69) (=> (= (x41 (select x62 x63)) x71) (=> (= x65 (store x67 x71 (d53 (x46 (x43 (select x62 x63)))))) (=> (= x70 (store x62 x63 (let ((x77 (select x62 x63))) (x44 (x38 x77) (x39 x77) (x40 x77) (x41 x77) (x42 x77) x32)))) (=> (= x68 (store x70 x63 (let ((x78 (select x70 x63))) (x44 x4 (x39 x78) (x40 x78) (x41 x78) (x42 x78) (x43 x78))))) + (=> (= (store x65 x69 (x51 (let ((x82 (ite (is-x49 (select x65 x69)) (let ((x79 (x48 (select x65 x69)))) (x57 x79)) (ite (is-x51 (select x65 x69)) (let ((x80 (x50 (select x65 x69)))) x80) (let ((x81 (s52 (select x65 x69)))) (x58 x81)))))) (x28 x4 x3 (x25 x82) (x26 x82) (+ (x27 (ite (is-x49 (select x65 x69)) (let ((x83 (x48 (select x65 x69)))) (x57 x83)) (ite (is-x51 (select x65 x69)) (let ((x84 (x50 (select x65 x69)))) x84) (let ((x85 (s52 (select x65 x69)))) (x58 x85))))) 1))))) x64) (forall ((x86 x6)) (=> (and (= x3 (x7 x86)) (= x3 (select x61 x86)) (= (select x66 x86) x16)) (= (ite (is-d53 (select x64 x86)) x3 x4) x3))))))))) (= x3 (x38 (select x62 x63)))) x3 x4) (ite (forall ((x87 x6)) (=> (and (= x3 (select x61 x87)) (= x3 (x7 x87)) (= x16 (select x66 x87))) (= x3 (ite (is-d53 (select x67 x87)) x3 x4)))) x3 x4)) x3)))) +(check-sat) diff --git a/test/regress/regress1/fmf/bug651.smt2 b/test/regress/regress1/fmf/bug651.smt2 new file mode 100644 index 000000000..bcfeebd69 --- /dev/null +++ b/test/regress/regress1/fmf/bug651.smt2 @@ -0,0 +1,43 @@ +; COMMAND-LINE: --fmf-fun --no-check-models --lang=smt2.5 +; EXPECT: sat +(set-logic UFDTSLIA) +(set-info :smt-lib-version 2.5) +(set-option :produce-models true) + +(declare-datatypes () ( + (Conditional_Int (Conditional_Int$CAbsent_Int) (Conditional_Int$CPresent_Int (Conditional_Int$CPresent_Int$value Int))) + (Conditional_T_titleType (Conditional_T_titleType$CAbsent_T_titleType) (Conditional_T_titleType$CPresent_T_titleType (Conditional_T_titleType$CPresent_T_titleType$value T_titleType))) + (Conditional_boolean (Conditional_boolean$CAbsent_boolean) (Conditional_boolean$CPresent_boolean (Conditional_boolean$CPresent_boolean$value Bool))) + (Conditional_string (Conditional_string$CAbsent_string) (Conditional_string$CPresent_string (Conditional_string$CPresent_string$value String))) + (Double (Double$CINF) (Double$CNINF) (Double$CNaN) (Double$CValue (Double$CValue$value Int))) + (List_T_titleType (List_T_titleType$CNil_T_titleType) (List_T_titleType$Cstr_T_titleType (List_T_titleType$Cstr_T_titleType$head T_titleType) (List_T_titleType$Cstr_T_titleType$tail List_T_titleType))) + (List_boolean (List_boolean$CNil_boolean) (List_boolean$Cstr_boolean (List_boolean$Cstr_boolean$head Bool) (List_boolean$Cstr_boolean$tail List_boolean))) + (List_string (List_string$CNil_string) (List_string$Cstr_string (List_string$Cstr_string$head String) (List_string$Cstr_string$tail List_string))) + (T_titleType (T_titleType$C_T_titleType (T_titleType$C_T_titleType$base String))) +) ) + +(define-fun f1361$isValid_string((x String)) Bool true) +(define-fun f5131$isValid_T_titleType((x T_titleType)) Bool (and (f1361$isValid_string (T_titleType$C_T_titleType$base x)) (<= (str.len (T_titleType$C_T_titleType$base x)) 80))) +(define-funs-rec + ( + (f5242$isValidElementsList_T_titleType((x List_T_titleType)) Bool) + ) + ( + (=> (is-List_T_titleType$Cstr_T_titleType x) (and (f5131$isValid_T_titleType (List_T_titleType$Cstr_T_titleType$head x)) (f5242$isValidElementsList_T_titleType (List_T_titleType$Cstr_T_titleType$tail x)))) + ) +) +(define-fun f1348$isValid_boolean((x Bool)) Bool true) +(define-funs-rec + ( + (f4169$isValidElementsList_boolean((x List_boolean)) Bool) + ) + ( + (=> (is-List_boolean$Cstr_boolean x) (and (f1348$isValid_boolean (List_boolean$Cstr_boolean$head x)) (f4169$isValidElementsList_boolean (List_boolean$Cstr_boolean$tail x)))) + ) +) + + +(declare-const title T_titleType) +(check-sat) + + diff --git a/test/regress/regress1/fmf/bug723-irrelevant-funs.smt2 b/test/regress/regress1/fmf/bug723-irrelevant-funs.smt2 new file mode 100644 index 000000000..e9b748744 --- /dev/null +++ b/test/regress/regress1/fmf/bug723-irrelevant-funs.smt2 @@ -0,0 +1,52 @@ +; COMMAND-LINE: --fmf-fun-rlv --no-check-models --lang=smt2.5 +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(define-fun $$isTrue$$ ((b Bool)) Bool b) +(define-fun $$isFalse$$ ((b Bool)) Bool (not b)) +(define-fun $$toString$$ ((b Bool)) String (ite b "true" "false") ) +(define-fun $$fromString$$ ((s String)) Bool (= s "true") ) +(define-fun $$inttostr$$ ((i Int)) String (ite (< i 0) (str.++ "-" (int.to.str (- i))) (int.to.str i))) +(declare-fun $$takeWhile$$ (String String) String) +(declare-fun $$takeWhileNot$$ (String String) String) +(declare-fun $$dropWhile$$ (String String) String) +(declare-fun $$dropWhileNot$$ (String String) String) +(declare-datatypes () ( + (AddressType (AddressType$C_AddressType (AddressType$C_AddressType$address String) (AddressType$C_AddressType$city String) (AddressType$C_AddressType$region String) (AddressType$C_AddressType$postalCode String) (AddressType$C_AddressType$country String))) + (Conditional_Int (Conditional_Int$CAbsent_Int) (Conditional_Int$CPresent_Int (Conditional_Int$CPresent_Int$value Int))) + (Conditional_dateTime (Conditional_dateTime$CAbsent_dateTime) (Conditional_dateTime$CPresent_dateTime (Conditional_dateTime$CPresent_dateTime$value Int))) + (Conditional_string (Conditional_string$CAbsent_string) (Conditional_string$CPresent_string (Conditional_string$CPresent_string$value String))) + (CustomerType (CustomerType$C_CustomerType (CustomerType$C_CustomerType$companyName String) (CustomerType$C_CustomerType$contactName String) (CustomerType$C_CustomerType$contactTitle String) (CustomerType$C_CustomerType$phone String) (CustomerType$C_CustomerType$fax Conditional_string) (CustomerType$C_CustomerType$fullAddress AddressType) (CustomerType$C_CustomerType$customerID Int))) + (List_CustomerType (List_CustomerType$CNil_CustomerType) (List_CustomerType$Cstr_CustomerType (List_CustomerType$Cstr_CustomerType$head CustomerType) (List_CustomerType$Cstr_CustomerType$tail List_CustomerType))) + (List_OrderType (List_OrderType$CNil_OrderType) (List_OrderType$Cstr_OrderType (List_OrderType$Cstr_OrderType$head OrderType) (List_OrderType$Cstr_OrderType$tail List_OrderType))) + (OrderType (OrderType$C_OrderType (OrderType$C_OrderType$customerID Int) (OrderType$C_OrderType$employeeID Int) (OrderType$C_OrderType$orderDate Int) (OrderType$C_OrderType$requiredDate Int) (OrderType$C_OrderType$shipInfo ShipInfoType))) + (RootType (RootType$C_RootType (RootType$C_RootType$customers List_CustomerType) (RootType$C_RootType$orders List_OrderType))) + (ShipInfoType (ShipInfoType$C_ShipInfoType (ShipInfoType$C_ShipInfoType$shipVia Int) (ShipInfoType$C_ShipInfoType$freight Int) (ShipInfoType$C_ShipInfoType$shipName String) (ShipInfoType$C_ShipInfoType$shipAddress String) (ShipInfoType$C_ShipInfoType$shipCity String) (ShipInfoType$C_ShipInfoType$shipRegion String) (ShipInfoType$C_ShipInfoType$shipPostalCode String) (ShipInfoType$C_ShipInfoType$shipCountry String) (ShipInfoType$C_ShipInfoType$shippedDate Conditional_dateTime))) +) ) + +(define-fun f2866$toXml((a$$2869 AddressType)) String (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ "<FullAddress>" "<Address>") (AddressType$C_AddressType$address a$$2869)) "</Address>") "<City>") (AddressType$C_AddressType$city a$$2869)) "</City>") "<Region>") (AddressType$C_AddressType$region a$$2869)) "</Region>") "<PostalCode>") (AddressType$C_AddressType$postalCode a$$2869)) "</PostalCode>") "<Country>") (AddressType$C_AddressType$country a$$2869)) "</Country>") "</FullAddress>")) +(define-fun f2656$toXml((c$$2659 CustomerType)) String (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ "<Customer CustomerID=" ($$inttostr$$ (CustomerType$C_CustomerType$customerID c$$2659))) ">") "<CompanyName>") (CustomerType$C_CustomerType$companyName c$$2659)) "</CompanyName>") "<ContactName>") (CustomerType$C_CustomerType$contactName c$$2659)) "</ContactName>") "<ContactTitle>") (CustomerType$C_CustomerType$contactTitle c$$2659)) "</ContactTitle>") "<Phone>") (CustomerType$C_CustomerType$phone c$$2659)) "</Phone>") (ite (is-Conditional_string$CPresent_string (CustomerType$C_CustomerType$fax c$$2659)) (str.++ (str.++ "<Fax>" (Conditional_string$CPresent_string$value (CustomerType$C_CustomerType$fax c$$2659))) "</Fax>") "")) (f2866$toXml (CustomerType$C_CustomerType$fullAddress c$$2659))) "</Customer>")) +(define-funs-rec + ( + (f2574$toXml((lc$$2577 List_CustomerType)) String) + ) + ( + (ite (is-List_CustomerType$CNil_CustomerType lc$$2577) "" (str.++ (f2656$toXml (List_CustomerType$Cstr_CustomerType$head lc$$2577)) (f2574$toXml (List_CustomerType$Cstr_CustomerType$tail lc$$2577)))) + ) +) +(define-fun f2942$toXml((s$$2945 ShipInfoType)) String (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ "<ShipInfo" (ite (is-Conditional_dateTime$CPresent_dateTime (ShipInfoType$C_ShipInfoType$shippedDate s$$2945)) (str.++ (str.++ " ShippedDate=" ($$inttostr$$ (Conditional_dateTime$CPresent_dateTime$value (ShipInfoType$C_ShipInfoType$shippedDate s$$2945)))) ">") ">")) "<ShipVia>") ($$inttostr$$ (ShipInfoType$C_ShipInfoType$shipVia s$$2945))) "</ShipVia>") "<Freight>") ($$inttostr$$ (ShipInfoType$C_ShipInfoType$freight s$$2945))) "</Freight>") "<ShipName>") (ShipInfoType$C_ShipInfoType$shipName s$$2945)) "</ShipName>") "<ShipAddress>") (ShipInfoType$C_ShipInfoType$shipAddress s$$2945)) "</ShipAddress>") "<ShipCity>") (ShipInfoType$C_ShipInfoType$shipCity s$$2945)) "</ShipCity>") "<ShipRegion>") (ShipInfoType$C_ShipInfoType$shipRegion s$$2945)) "</ShipRegion>") "<ShipPostalCode>") (ShipInfoType$C_ShipInfoType$shipPostalCode s$$2945)) "</ShipPostalCode>") "<ShipCountry>") (ShipInfoType$C_ShipInfoType$shipCountry s$$2945)) "</ShipCountry>") "</ShipInfo>")) +(define-fun f2776$toXml((o$$2779 OrderType)) String (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ "<Order>" "<CustomerID>") ($$inttostr$$ (OrderType$C_OrderType$customerID o$$2779))) "</CustomerID>") "<EmployeeID>") ($$inttostr$$ (OrderType$C_OrderType$employeeID o$$2779))) "</EmployeeID>") "<OrderDate>") ($$inttostr$$ (OrderType$C_OrderType$orderDate o$$2779))) "</OrderDate>") "<RequiredDate>") ($$inttostr$$ (OrderType$C_OrderType$requiredDate o$$2779))) "</RequiredDate>") (f2942$toXml (OrderType$C_OrderType$shipInfo o$$2779))) "</Order>")) +(define-funs-rec + ( + (f2615$toXml((lo$$2618 List_OrderType)) String) + ) + ( + (ite (is-List_OrderType$CNil_OrderType lo$$2618) "" (str.++ (f2776$toXml (List_OrderType$Cstr_OrderType$head lo$$2618)) (f2615$toXml (List_OrderType$Cstr_OrderType$tail lo$$2618)))) + ) +) +(define-fun f2526$toXml((r$$2529 RootType)) String (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ (str.++ "<Root>" "<Customers>") (f2574$toXml (RootType$C_RootType$customers r$$2529))) "</Customers>") "<Orders>") (f2615$toXml (RootType$C_RootType$orders r$$2529))) "</Orders>") "</Root>")) + +(declare-fun $Report$3105$0$1$() String) +(assert (= $Report$3105$0$1$ "<Root><Customers></Customers><Orders></Orders></Root>")) +; should be fast since functions introduced by define-fun-rec do not appear in the ground assertion +(check-sat) + diff --git a/test/regress/regress1/fmf/bug764.smt2 b/test/regress/regress1/fmf/bug764.smt2 new file mode 100644 index 000000000..3172fd695 --- /dev/null +++ b/test/regress/regress1/fmf/bug764.smt2 @@ -0,0 +1,28 @@ +; COMMAND-LINE: --fmf-fun --no-check-models --lang=smt2.5 +; EXPECT: sat +(set-logic ALL) +(set-info :status sat) + +(define-fun BoolToString ((b Bool)) String (ite b "true" "false") ) + +(declare-datatypes () ( + (Color (red) (white) (blue)) +) ) + +(define-fun ColorToString ((c Color)) String (ite (is-red c) "red" (ite (is-white c) "white" "blue")) ) + +(declare-datatypes () ( + (CP (cp (b Bool) (c Color))) +) ) + +(define-fun-rec CPToString ((cp CP)) String (str.++ "cp(" (BoolToString (b cp)) "," (ColorToString (c cp)) ")")) + +(declare-fun CPFromString (String) CP) + +(assert (forall ((cp1 CP)) (= cp1 (CPFromString (CPToString cp1))))) + +(declare-fun cpx() CP) +(assert (= cpx (CPFromString "cp(true,white)"))) + +(check-sat) + diff --git a/test/regress/regress1/fmf/cons-sets-bounds.smt2 b/test/regress/regress1/fmf/cons-sets-bounds.smt2 new file mode 100644 index 000000000..5e3c2952b --- /dev/null +++ b/test/regress/regress1/fmf/cons-sets-bounds.smt2 @@ -0,0 +1,26 @@ +; COMMAND-LINE: --fmf-bound +; EXPECT: sat +(set-logic ALL) +(declare-datatypes ((list 0)) (((cons (head Int) (tail list)) (nil)))) + +(declare-fun P (Int) Bool) +(declare-fun S () (Set list)) + +; can use simple unification to infer bounds on x and y +(assert (forall ((x Int) (y list)) (=> (member (cons x y) S) (P x)))) + +(assert (member (cons 4 (cons 1 nil)) S)) +(assert (member (cons 2 nil) S)) + +; should construct instantiation involving selectors for l +(declare-fun l () list) +(assert ((_ is cons) l)) +(assert (member l S)) + +; should not contribute to instantiations +(assert (member nil S)) + +(assert (not (P 1))) +(assert (not (P 0))) + +(check-sat) diff --git a/test/regress/regress1/fmf/constr-ground-to.smt2 b/test/regress/regress1/fmf/constr-ground-to.smt2 new file mode 100644 index 000000000..bc6d9e948 --- /dev/null +++ b/test/regress/regress1/fmf/constr-ground-to.smt2 @@ -0,0 +1,43 @@ +; COMMAND-LINE: --fmf-fun --lang=smt2.5 +; EXPECT: sat +(set-logic UFDTLIA) +(declare-datatypes () ( + ( + Term + (str (sv IntList)) + ) + ( + IntList + (sn) + (sc (sh Int) (st IntList)) + ) +)) +(declare-const t Term) +(assert ( + and + (is-str t) + (is-sc (sv t)) + (is-sc (st (sv t))) + (is-sc (st (st (sv t)))) + (is-sc (st (st (st (sv t))))) + (is-sc (st (st (st (st (sv t)))))) + (is-sc (st (st (st (st (st (sv t))))))) + (is-sc (st (st (st (st (st (st (sv t)))))))) + (is-sc (st (st (st (st (st (st (st (sv t))))))))) + (is-sc (st (st (st (st (st (st (st (st (sv t)))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (sv t))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (sv t)))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (sv t))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (sv t)))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t)))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t))))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t)))))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t))))))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t)))))))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t))))))))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t)))))))))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t))))))))))))))))))))))) + (is-sc (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (st (sv t)))))))))))))))))))))))) +)) +(check-sat) diff --git a/test/regress/regress1/fmf/datatypes-ufinite-nested.smt2 b/test/regress/regress1/fmf/datatypes-ufinite-nested.smt2 new file mode 100644 index 000000000..6b30907ae --- /dev/null +++ b/test/regress/regress1/fmf/datatypes-ufinite-nested.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --finite-model-find +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(declare-sort U 0) +(declare-fun a () U) +(declare-fun b () U) +(declare-fun c () U) +(declare-fun d () U) +(assert (distinct a b c)) +(declare-sort V 0) +(declare-datatypes ((ufin1 0) (ufin2 0)) (((cons1 (s11 U) (s13 ufin2))) ((cons2 (s21 V) (s22 U)) (cons3)))) +(declare-fun P (ufin1 ufin2) Bool) +(declare-fun Q (ufin1 ufin1) Bool) +(assert (forall ((x ufin1) (y ufin2) (z ufin1)) (or (P x y) (Q x z)))) +(assert (not (P (cons1 a cons3) cons3))) +(assert (not (Q (cons1 b cons3) (cons1 a cons3)))) +(check-sat) diff --git a/test/regress/regress1/fmf/datatypes-ufinite.smt2 b/test/regress/regress1/fmf/datatypes-ufinite.smt2 new file mode 100644 index 000000000..a19c8f027 --- /dev/null +++ b/test/regress/regress1/fmf/datatypes-ufinite.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(declare-sort U 0) +(declare-fun a () U) +(declare-fun b () U) +(declare-fun c () U) +(declare-fun d () U) +(assert (distinct a b c)) +(declare-sort V 0) +(declare-datatypes () ((ufin1 (cons1 (s11 U) (s12 U))) (ufin2 (cons2 (s21 V) (s22 U)) (cons3)))) +(declare-fun P (ufin1 ufin2) Bool) +(declare-fun Q (ufin1 ufin1) Bool) +(assert (forall ((x ufin1) (y ufin2) (z ufin1)) (or (P x y) (Q x z)))) +(assert (not (P (cons1 a a) cons3))) +(assert (not (Q (cons1 a d) (cons1 a b)))) +(check-sat) diff --git a/test/regress/regress1/fmf/dt-proper-model.smt2 b/test/regress/regress1/fmf/dt-proper-model.smt2 new file mode 100644 index 000000000..0e66db996 --- /dev/null +++ b/test/regress/regress1/fmf/dt-proper-model.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --finite-model-find +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-sort U 0) +(declare-datatypes ((D 0)) (((cons (x Int) (y U))))) +(declare-fun d1 () D) +(declare-fun d2 () D) +(declare-fun d3 () D) +(declare-fun d4 () D) +(assert (distinct d1 d2 d3 d4)) +(assert (forall ((x U) (y U)) (= x y))) +(declare-fun a () U) +(declare-fun P (U) Bool) +(assert (P a)) +(check-sat) diff --git a/test/regress/regress1/fmf/fc-pigeonhole19.smt2 b/test/regress/regress1/fmf/fc-pigeonhole19.smt2 new file mode 100644 index 000000000..f145013d8 --- /dev/null +++ b/test/regress/regress1/fmf/fc-pigeonhole19.smt2 @@ -0,0 +1,20 @@ +(set-logic UFC) +(set-info :status unsat) + +(declare-sort P 0) +(declare-sort H 0) + +(declare-fun p () P) +(declare-fun h () H) + +; pigeonhole using native cardinality constraints +(assert (fmf.card p 19)) +(assert (not (fmf.card p 18))) +(assert (fmf.card h 18)) +(assert (not (fmf.card h 17))) + +; each pigeon has different holes +(declare-fun f (P) H) +(assert (forall ((p1 P) (p2 P)) (=> (not (= p1 p2)) (not (= (f p1) (f p2)))))) + +(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/fmf/fib-core.smt2 b/test/regress/regress1/fmf/fib-core.smt2 new file mode 100644 index 000000000..e00f19ad4 --- /dev/null +++ b/test/regress/regress1/fmf/fib-core.smt2 @@ -0,0 +1,19 @@ +; COMMAND-LINE: --finite-model-find --fmf-inst-engine +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-sort I_fb 0) +(declare-fun fb_arg_0_1 (I_fb) Int) +(declare-fun fb (Int) Int) + +(assert (forall ((?j I_fb)) (= (fb (fb_arg_0_1 ?j)) (ite (not (>= (fb_arg_0_1 ?j) 2)) (fb_arg_0_1 ?j) (+ (fb (+ (- 1) (fb_arg_0_1 ?j))) (fb (+ (- 2) (fb_arg_0_1 ?j)))))) ) ) + +(assert (forall ((?i I_fb)) (ite (not (>= (fb_arg_0_1 ?i) 2)) true (and (not (forall ((?z I_fb)) (not (= (fb_arg_0_1 ?i) (+ 1 (fb_arg_0_1 ?z)))) )) (not (forall ((?z I_fb)) (not (= (fb_arg_0_1 ?i) (+ 2 (fb_arg_0_1 ?z)))) )))) ) ) + +(assert (forall ((?i I_fb)) (or (>= (fb_arg_0_1 ?i) 2) (and (not (>= (fb_arg_0_1 ?i) 2)) (not (forall ((?z I_fb)) (not (= (fb_arg_0_1 ?i) (+ 1 (fb_arg_0_1 ?z)))) )) (not (forall ((?z I_fb)) (not (= (fb_arg_0_1 ?i) (+ 2 (fb_arg_0_1 ?z)))) )))) )) + + +(assert (not (= (fb 5) 5)) ) +(assert (not (forall ((?z I_fb)) (not (= (fb_arg_0_1 ?z) 5)) ))) + +(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/fmf/fmf-bound-2dim.smt2 b/test/regress/regress1/fmf/fmf-bound-2dim.smt2 new file mode 100644 index 000000000..5f5c22770 --- /dev/null +++ b/test/regress/regress1/fmf/fmf-bound-2dim.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --fmf-bound +; EXPECT: sat +(set-logic ALL) +(set-info :status sat) +(declare-fun P (Int Int) Bool) + +(declare-fun a () Int) +(assert (> a 10)) + +(assert (forall ((x Int) (y Int)) +(=> (and (<= a x) (<= x (+ a 5)) (<= 14 y) (<= y (+ 7 x))) +(P x y)))) +(assert (not (P 15 4))) + +(check-sat) diff --git a/test/regress/regress1/fmf/fmf-bound-int.smt2 b/test/regress/regress1/fmf/fmf-bound-int.smt2 new file mode 100644 index 000000000..fb3106bdf --- /dev/null +++ b/test/regress/regress1/fmf/fmf-bound-int.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --finite-model-find --fmf-bound-int +; EXPECT: sat +(set-logic UFLIA) +(declare-fun P (Int Int) Bool) +(declare-fun Q (Int) Bool) +(assert (forall ((x Int)) (=> (and (<= 0 x) (<= x (ite (P 0 0) 10 20))) (Q x)))) +(check-sat) diff --git a/test/regress/regress1/fmf/fmf-fun-no-elim-ext-arith.smt2 b/test/regress/regress1/fmf/fmf-fun-no-elim-ext-arith.smt2 new file mode 100644 index 000000000..0618e28cb --- /dev/null +++ b/test/regress/regress1/fmf/fmf-fun-no-elim-ext-arith.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --fmf-fun --no-check-models --rewrite-divk +; EXPECT: sat +(set-logic UFLIA) +(set-info :status sat) +(define-fun-rec int-and ((n Int) (n1 Int) (n2 Int)) Bool ( + or + (= n1 n 0) + (= n2 n 0) + ( + and + (> n1 0) + (> n2 0) + (>= n 0) + (= (not (= (mod n 2 ) 0)) (and (not (= (mod n1 2 ) 0)) (not (= (mod n2 2) 0)))) + (int-and (div n 2) (div n1 2) (div n2 2)) + ) +)) +(check-sat) diff --git a/test/regress/regress1/fmf/fmf-fun-no-elim-ext-arith2.smt2 b/test/regress/regress1/fmf/fmf-fun-no-elim-ext-arith2.smt2 new file mode 100644 index 000000000..07f1e6674 --- /dev/null +++ b/test/regress/regress1/fmf/fmf-fun-no-elim-ext-arith2.smt2 @@ -0,0 +1,25 @@ +; COMMAND-LINE: --fmf-fun --no-check-models --rewrite-divk +; EXPECT: sat +(set-logic UFLIA) +(set-info :status sat) +(define-fun-rec int-and ((n Int) (n1 Int) (n2 Int)) Bool ( + or + (= n1 n 0) + (= n2 n 0) + ( + and + (> n1 0) + (> n2 0) + (>= n 0) + (= (not (= (mod n 2 ) 0)) (and (not (= (mod n1 2 ) 0)) (not (= (mod n2 2) 0)))) + (int-and (div n 2) (div n1 2) (div n2 2)) + ) +)) +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) +(assert (= x 1)) +(assert (= y 1)) +(assert (= z 1)) +(assert (int-and z x y)) +(check-sat) diff --git a/test/regress/regress1/fmf/fmf-strange-bounds.smt2 b/test/regress/regress1/fmf/fmf-strange-bounds.smt2 new file mode 100644 index 000000000..7812c2431 --- /dev/null +++ b/test/regress/regress1/fmf/fmf-strange-bounds.smt2 @@ -0,0 +1,35 @@ +; COMMAND-LINE: --fmf-bound +; EXPECT: sat +(set-logic ALL) +(set-info :status sat) +(declare-sort U 0) +(declare-fun P (Int Int U) Bool) + +(declare-fun S () (Set Int)) + +(declare-fun f (Int) U) +(declare-fun g (Int) U) + +(declare-fun h (U) Int) + +(assert (member 77 S)) +(assert (>= (h (f 77)) 3)) +(assert (>= (h (g 77)) 2)) +(assert (not (= (g 77) (f 77)))) + +(assert (forall ((x Int) (y Int) (z U)) (=> +(or (= z (f x)) (= z (g x))) +(=> (member x S) +(=> (and (<= 0 y) (<= y (h z))) +(P x y z)))))) + + +(declare-fun Q (U Int) Bool) +(declare-const a U) +(declare-const b U) +(declare-const c U) +(assert (distinct a b c)) +(assert (forall ((x U) (y Int)) (=> (and (<= 3 y) (<= y 10) (or (= x c) (= x (f y)))) (Q x y)))) +(assert (not (Q b 6))) + +(check-sat) diff --git a/test/regress/regress1/fmf/forall_unit_data.smt2 b/test/regress/regress1/fmf/forall_unit_data.smt2 new file mode 100644 index 000000000..6971c4d0a --- /dev/null +++ b/test/regress/regress1/fmf/forall_unit_data.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: sat +(set-option :produce-models true) +(set-option :interactive-mode true) +(set-logic ALL_SUPPORTED) +(declare-sort a 0) +(declare-datatypes () ((w (Wrap (unw a))))) +(declare-fun x () w) +(assert (forall ((y w)) (= x y))) +(check-sat) diff --git a/test/regress/regress1/fmf/fore19-exp2-core.smt2 b/test/regress/regress1/fmf/fore19-exp2-core.smt2 new file mode 100644 index 000000000..4b4d57af3 --- /dev/null +++ b/test/regress/regress1/fmf/fore19-exp2-core.smt2 @@ -0,0 +1,72 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-datatypes () ((St (Block!2236 (body!2237 List!2293)) (For!2238 (init!2239 St) (expr!2240 Ex) (step!2241 St) (body!2242 St)) (IfTE (expr!2244 Ex) (then!2245 St) (elze!2246 St)) (Skip!2250) (While (expr!2252 Ex) (body St))) +(Ex (Var!2291 (varID!2292 (_ BitVec 32)))) +(List!2293 (Cons!2294 (head!2295 St) (tail!2296 List!2293)) (Nil!2297)) +)) +(declare-fun error_value!2298 () Bool) +(declare-fun error_value!2299 () List!2293) +(declare-fun s () St) +(declare-fun body!2242_uf_1 (St) St) +(declare-fun step!2241_uf_2 (St) St) +(declare-fun init!2239_uf_3 (St) St) +(declare-fun elze!2246_uf_4 (St) St) +(declare-fun then!2245_uf_5 (St) St) +(declare-fun body!2237_uf_6 (St) List!2293) +(declare-fun tail!2296_uf_7 (List!2293) List!2293) +(declare-fun head!2295_uf_8 (List!2293) St) +(declare-fun expr!2240_uf_9 (St) Ex) +(declare-fun body_uf_10 (St) St) +(declare-fun expr!2252_uf_11 (St) Ex) +(declare-fun expr!2244_uf_12 (St) Ex) +(declare-fun iwf (St) Bool) +(declare-fun iwfl (List!2293) Bool) +(declare-fun ewl (St) St) +(declare-fun ewlList!211 (List!2293) List!2293) +(declare-sort I_iwf 0) +(declare-fun iwf_arg_0_13 (I_iwf) St) +(declare-sort I_iwfl 0) +(declare-fun iwfl_arg_0_14 (I_iwfl) List!2293) +(declare-sort I_ewl 0) +(declare-fun ewl_arg_0_15 (I_ewl) St) +(declare-sort I_ewlList!211 0) +(declare-fun ewlList!211_arg_0_16 (I_ewlList!211) List!2293) +(declare-fun termITE_17 () St) +(declare-fun termITE_18 () St) +(declare-fun termITE_19 () St) +(declare-fun termITE_20 () St) + +(assert +(and +(forall ((?i1 I_ewl)) (= (ewl (ewl_arg_0_15 ?i1)) + +(ite (is-IfTE (ewl_arg_0_15 ?i1)) (IfTE (ite (is-IfTE (ewl_arg_0_15 ?i1)) (expr!2244 (ewl_arg_0_15 ?i1)) (expr!2244_uf_12 (ewl_arg_0_15 ?i1))) (ewl (ite (is-IfTE (ewl_arg_0_15 ?i1)) (then!2245 (ewl_arg_0_15 ?i1)) (then!2245_uf_5 (ewl_arg_0_15 ?i1)))) (ewl (ite (is-IfTE (ewl_arg_0_15 ?i1)) (elze!2246 (ewl_arg_0_15 ?i1)) (elze!2246_uf_4 (ewl_arg_0_15 ?i1))))) + +(ite (is-While (ewl_arg_0_15 ?i1)) (For!2238 Skip!2250 (ite (is-While (ewl_arg_0_15 ?i1)) (expr!2252 (ewl_arg_0_15 ?i1)) (expr!2252_uf_11 (ewl_arg_0_15 ?i1))) Skip!2250 (ewl (ite (is-While (ewl_arg_0_15 ?i1)) (body (ewl_arg_0_15 ?i1)) (body_uf_10 (ewl_arg_0_15 ?i1))))) + +(ite (is-For!2238 (ewl_arg_0_15 ?i1)) (For!2238 (ewl (ite (is-For!2238 (ewl_arg_0_15 ?i1)) (init!2239 (ewl_arg_0_15 ?i1)) (init!2239_uf_3 (ewl_arg_0_15 ?i1)))) (ite (is-For!2238 (ewl_arg_0_15 ?i1)) (expr!2240 (ewl_arg_0_15 ?i1)) (expr!2240_uf_9 (ewl_arg_0_15 ?i1))) (ewl (ite (is-For!2238 (ewl_arg_0_15 ?i1)) (step!2241 (ewl_arg_0_15 ?i1)) (step!2241_uf_2 (ewl_arg_0_15 ?i1)))) (ewl (ite (is-For!2238 (ewl_arg_0_15 ?i1)) (body!2242 (ewl_arg_0_15 ?i1)) (body!2242_uf_1 (ewl_arg_0_15 ?i1))))) + +(ewl_arg_0_15 ?i1))))) ) + + +(forall ((?i2 I_ewl)) (ite (is-IfTE (ewl_arg_0_15 ?i2)) (and (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) (ite (is-IfTE (ewl_arg_0_15 ?i2)) (then!2245 (ewl_arg_0_15 ?i2)) (then!2245_uf_5 (ewl_arg_0_15 ?i2))))) )) (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) (ite (is-IfTE (ewl_arg_0_15 ?i2)) (elze!2246 (ewl_arg_0_15 ?i2)) (elze!2246_uf_4 (ewl_arg_0_15 ?i2))))) ))) (ite (is-While (ewl_arg_0_15 ?i2)) (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) (ite (is-While (ewl_arg_0_15 ?i2)) (body (ewl_arg_0_15 ?i2)) (body_uf_10 (ewl_arg_0_15 ?i2))))) )) (ite (is-For!2238 (ewl_arg_0_15 ?i2)) (and (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) (ite (is-For!2238 (ewl_arg_0_15 ?i2)) (init!2239 (ewl_arg_0_15 ?i2)) (init!2239_uf_3 (ewl_arg_0_15 ?i2))))) )) (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) (ite (is-For!2238 (ewl_arg_0_15 ?i2)) (step!2241 (ewl_arg_0_15 ?i2)) (step!2241_uf_2 (ewl_arg_0_15 ?i2))))) )) (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) (ite (is-For!2238 (ewl_arg_0_15 ?i2)) (body!2242 (ewl_arg_0_15 ?i2)) (body!2242_uf_1 (ewl_arg_0_15 ?i2))))) ))) true))) ) +(forall ((?i3 I_iwf)) (= (iwf (iwf_arg_0_13 ?i3)) (ite (is-Block!2236 (iwf_arg_0_13 ?i3)) (iwfl (ite (is-Block!2236 (iwf_arg_0_13 ?i3)) (body!2237 (iwf_arg_0_13 ?i3)) (body!2237_uf_6 (iwf_arg_0_13 ?i3)))) (ite (is-IfTE (iwf_arg_0_13 ?i3)) (and (iwf (ite (is-IfTE (iwf_arg_0_13 ?i3)) (elze!2246 (iwf_arg_0_13 ?i3)) (elze!2246_uf_4 (iwf_arg_0_13 ?i3)))) (iwf (ite (is-IfTE (iwf_arg_0_13 ?i3)) (then!2245 (iwf_arg_0_13 ?i3)) (then!2245_uf_5 (iwf_arg_0_13 ?i3))))) (ite (is-While (iwf_arg_0_13 ?i3)) false (ite (is-For!2238 (iwf_arg_0_13 ?i3)) (and (iwf (ite (is-For!2238 (iwf_arg_0_13 ?i3)) (body!2242 (iwf_arg_0_13 ?i3)) (body!2242_uf_1 (iwf_arg_0_13 ?i3)))) (iwf (ite (is-For!2238 (iwf_arg_0_13 ?i3)) (step!2241 (iwf_arg_0_13 ?i3)) (step!2241_uf_2 (iwf_arg_0_13 ?i3)))) (iwf (ite (is-For!2238 (iwf_arg_0_13 ?i3)) (init!2239 (iwf_arg_0_13 ?i3)) (init!2239_uf_3 (iwf_arg_0_13 ?i3))))) true))))) ) +(forall ((?i4 I_iwf)) (ite (is-Block!2236 (iwf_arg_0_13 ?i4)) (not (forall ((?z I_iwfl)) (not (= (iwfl_arg_0_14 ?z) (ite (is-Block!2236 (iwf_arg_0_13 ?i4)) (body!2237 (iwf_arg_0_13 ?i4)) (body!2237_uf_6 (iwf_arg_0_13 ?i4))))) )) (ite (is-IfTE (iwf_arg_0_13 ?i4)) (and (not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) (ite (is-IfTE (iwf_arg_0_13 ?i4)) (elze!2246 (iwf_arg_0_13 ?i4)) (elze!2246_uf_4 (iwf_arg_0_13 ?i4))))) )) (not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) (ite (is-IfTE (iwf_arg_0_13 ?i4)) (then!2245 (iwf_arg_0_13 ?i4)) (then!2245_uf_5 (iwf_arg_0_13 ?i4))))) ))) (ite (is-While (iwf_arg_0_13 ?i4)) true (ite (is-For!2238 (iwf_arg_0_13 ?i4)) (and (not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) (ite (is-For!2238 (iwf_arg_0_13 ?i4)) (body!2242 (iwf_arg_0_13 ?i4)) (body!2242_uf_1 (iwf_arg_0_13 ?i4))))) )) (not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) (ite (is-For!2238 (iwf_arg_0_13 ?i4)) (step!2241 (iwf_arg_0_13 ?i4)) (step!2241_uf_2 (iwf_arg_0_13 ?i4))))) )) (not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) (ite (is-For!2238 (iwf_arg_0_13 ?i4)) (init!2239 (iwf_arg_0_13 ?i4)) (init!2239_uf_3 (iwf_arg_0_13 ?i4))))) ))) true)))) ) +(is-IfTE s) +(iwf s) +(not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) s)) )) +(ite (is-IfTE s) (= termITE_17 (then!2245 s)) (= termITE_17 (then!2245_uf_5 s))) +(ite (is-IfTE s) (= termITE_18 (then!2245 s)) (= termITE_18 (then!2245_uf_5 s))) +(=> (and (iwf termITE_17) (not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) termITE_18)) ))) (and (= (ewl termITE_17) termITE_17) (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) termITE_18)) )))) +(ite (is-IfTE s) (= termITE_19 (elze!2246 s)) (= termITE_19 (elze!2246_uf_4 s))) +(ite (is-IfTE s) (= termITE_20 (elze!2246 s)) (= termITE_20 (elze!2246_uf_4 s))) +(=> (and (iwf termITE_19) (not (forall ((?z I_iwf)) (not (= (iwf_arg_0_13 ?z) termITE_20)) ))) (and (= (ewl termITE_19) termITE_19) (not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) termITE_20)) )))) +(not (= (ewl s) s)) +(not (forall ((?z I_ewl)) (not (= (ewl_arg_0_15 ?z) s)) )) + + +) +) +(check-sat) diff --git a/test/regress/regress1/fmf/german169.smt2 b/test/regress/regress1/fmf/german169.smt2 new file mode 100644 index 000000000..c88de064c --- /dev/null +++ b/test/regress/regress1/fmf/german169.smt2 @@ -0,0 +1,103 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-datatypes () ((UNIT (Unit)))) +(declare-datatypes () ((BOOL (Truth) (Falsity)))) + +; Decls -------------- +(declare-sort node$type 0) +(declare-sort data$type 0) +(declare-datatypes () ((cache_state$type (invalid) (shared) (exclusive)))) +(declare-datatypes () ((cache$type (c_cache$type (c_state cache_state$type) (c_data data$type))))) +(declare-datatypes () ((msg_cmd$type (empty) (reqs) (reqe) (inv) (invack) (gnts) (gnte)))) +(declare-datatypes () ((msg$type (c_msg$type (m_cmd msg_cmd$type) (m_data data$type))))) +(declare-fun dummy () data$type) + +; Var Decls -------------- +(declare-fun memdata$1 () data$type) +(declare-fun shrset$1 () (Array node$type BOOL)) +(declare-fun recv_invack$i () node$type) +(declare-fun exgntd () BOOL) +(declare-fun chan3$1 () (Array node$type msg$type)) +(declare-fun shrset () (Array node$type BOOL)) +(declare-fun exgntd$1 () BOOL) +(declare-fun chan2 () (Array node$type msg$type)) +(declare-fun chan3 () (Array node$type msg$type)) +(declare-fun auxnode () node$type) +(declare-fun curcmd () msg_cmd$type) + +; Asserts -------------- +(assert (not (=> (and (and (forall ((n node$type)) + (=> (= (m_cmd (select + chan2 + n)) + gnte) (= exgntd + Truth))) + (forall ((n node$type)) + (=> (= exgntd Truth) + (= (select shrset n) + (ite (= n auxnode) Truth + Falsity))))) (forall + ((n node$type)) + (=> (= + (m_cmd + (select + chan3 + n)) + invack) + (= (m_cmd + (select + chan2 + n)) + empty)))) + (=> (= (m_cmd (select chan3 recv_invack$i)) + invack) (=> (not (= curcmd empty)) + (=> (= chan3$1 (store + chan3 + recv_invack$i + (let ( + (vup_228 + (select + chan3 + recv_invack$i))) + (c_msg$type + empty + (m_data + vup_228))))) + (=> (= shrset$1 (store + shrset + recv_invack$i + Falsity)) + (= (ite (= exgntd Truth) + (ite (=> (= exgntd$1 + Falsity) + (=> (= memdata$1 + (m_data + (select + chan3$1 + recv_invack$i))) + (forall ( + (n node$type)) + (=> (= (m_cmd + (select + chan2 + n)) + gnte) + (= exgntd$1 + Truth))))) + Truth Falsity) + (ite (forall ( + (n node$type)) + (=> (= (m_cmd + (select + chan2 + n)) + gnte) + (= exgntd + Truth))) + Truth Falsity)) + Truth)))))))) + +(check-sat) +(exit) diff --git a/test/regress/regress1/fmf/german73.smt2 b/test/regress/regress1/fmf/german73.smt2 new file mode 100644 index 000000000..64f551d55 --- /dev/null +++ b/test/regress/regress1/fmf/german73.smt2 @@ -0,0 +1,105 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-datatypes () ((UNIT (Unit)))) +(declare-datatypes () ((BOOL (Truth) (Falsity)))) + +; Decls -------------- +(declare-sort node$type 0) +(declare-sort data$type 0) +(declare-datatypes () ((cache_state$type (invalid) (shared) (exclusive)))) +(declare-datatypes () ((cache$type (c_cache$type (c_state cache_state$type) (c_data data$type))))) +(declare-datatypes () ((msg_cmd$type (empty) (reqs) (reqe) (inv) (invack) (gnts) (gnte)))) +(declare-datatypes () ((msg$type (c_msg$type (m_cmd msg_cmd$type) (m_data data$type))))) +(declare-fun dummy () data$type) + +; Var Decls -------------- +(declare-fun memdata$1 () data$type) +(declare-fun shrset$1 () (Array node$type BOOL)) +(declare-fun recv_invack$i () node$type) +(declare-fun exgntd () BOOL) +(declare-fun invset () (Array node$type BOOL)) +(declare-fun chan3$1 () (Array node$type msg$type)) +(declare-fun shrset () (Array node$type BOOL)) +(declare-fun exgntd$1 () BOOL) +(declare-fun chan2 () (Array node$type msg$type)) +(declare-fun chan3 () (Array node$type msg$type)) +(declare-fun curcmd () msg_cmd$type) + +; Asserts -------------- +(assert (not (=> (and (forall ((n node$type)) + (=> (= (select invset n) + Truth) (= (select + shrset + n) Truth))) + (forall ((n node$type)) (=> + (or + (= + (m_cmd + (select + chan2 + n)) + inv) + (= + (m_cmd + (select + chan3 + n)) + invack)) + (not + (= + (select + invset + n) + Truth))))) + (=> (= (m_cmd (select chan3 recv_invack$i)) + invack) (=> (not (= curcmd empty)) + (=> (= chan3$1 (store + chan3 + recv_invack$i + (let ( + (vup_101 + (select + chan3 + recv_invack$i))) + (c_msg$type + empty + (m_data + vup_101))))) + (=> (= shrset$1 (store + shrset + recv_invack$i + Falsity)) + (= (ite (= exgntd Truth) + (ite (=> (= exgntd$1 + Falsity) + (=> (= memdata$1 + (m_data + (select + chan3$1 + recv_invack$i))) + (forall ( + (n node$type)) + (=> (= (select + invset + n) + Truth) + (= (select + shrset$1 + n) Truth))))) + Truth Falsity) + (ite (forall ( + (n node$type)) + (=> (= (select + invset + n) + Truth) + (= (select + shrset$1 + n) Truth))) + Truth Falsity)) + Truth)))))))) + +(check-sat) +(exit) diff --git a/test/regress/regress1/fmf/issue916-fmf-or.smt2 b/test/regress/regress1/fmf/issue916-fmf-or.smt2 new file mode 100644 index 000000000..0c51e39af --- /dev/null +++ b/test/regress/regress1/fmf/issue916-fmf-or.smt2 @@ -0,0 +1,48 @@ +; COMMAND-LINE: --fmf-fun --no-check-models +; EXPECT: sat + +(set-logic UFDTLIA) +(set-info :smt-lib-version 2.5) + +(define-funs-rec + ( + (validIdValue ((x Int)(v Int)) Bool) + ) + ( + (or + (and (= x 0) (< (- 10) v 10) ) + (and (= x 1) (<= (- 100) v (- 10)) ) + (and (= x 2) (<= 10 v 100) ) + (and (= x 3) (< (- 1000) v (- 100)) ) + (and (= x 4) (< 100 v 1000) ) + (and (= x 5) (<= (- 1000) v) ) + (and (= x 6) (<= v 1000) ) + (validIdValue (- x 7) v) + ) + ) +) + +(declare-datatypes (T) ( (List (Nil) (Cstr (head T) (tail List) ) ) ) ) +(declare-datatypes (T S) ( (Pair (Pair (first T) (second S)) ) ) ) + +(define-funs-rec + ( + (validList ((l (List (Pair Int Int)))) Bool) + ) + ( + (ite (= l (as Nil (List (Pair Int Int))) ) + true + (let ((hd (head l))) (and (>= (first hd) 0) + (validIdValue (first hd) (second hd)) + (validList (tail l)) + ) + ) + ) + ) +) + + +(declare-const myList (List (Pair Int Int))) +(assert (distinct myList (as Nil (List (Pair Int Int))))) +(assert (validList myList)) +(check-sat) diff --git a/test/regress/regress1/fmf/jasmin-cdt-crash.smt2 b/test/regress/regress1/fmf/jasmin-cdt-crash.smt2 new file mode 100644 index 000000000..7012838f9 --- /dev/null +++ b/test/regress/regress1/fmf/jasmin-cdt-crash.smt2 @@ -0,0 +1,100 @@ +; COMMAND-LINE: --finite-model-find --fmf-inst-engine --uf-ss-fair-monotone --lang=smt2.5 +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-sort a_ 0) +(declare-fun __nun_card_witness_0 () a_) +(declare-codatatypes () + ((llist_ (LCons_ (_select_LCons__0 a_) (_select_LCons__1 llist_)) + (LNil_ )))) +(declare-fun xs_ () llist_) +(declare-fun y_ () a_) +(declare-fun ys_ () llist_) +(declare-datatypes () ((_nat (_succ (_select__succ_0 _nat)) (_zero )))) +(declare-fun decr_lprefix_ () _nat) +(declare-sort G_lprefix__neg 0) +(declare-fun __nun_card_witness_1 () G_lprefix__neg) +(declare-fun lprefix__- (_nat llist_ llist_) Bool) +(declare-fun proj_G_lprefix__neg_0 (G_lprefix__neg) _nat) +(declare-fun proj_G_lprefix__neg_1 (G_lprefix__neg) llist_) +(declare-fun proj_G_lprefix__neg_2 (G_lprefix__neg) llist_) +(assert + (forall ((a/60 G_lprefix__neg)) + (=> + (or (= (proj_G_lprefix__neg_0 a/60) _zero) + (and (is-_succ (proj_G_lprefix__neg_0 a/60)) + (= (proj_G_lprefix__neg_1 a/60) LNil_)) + (and + (=> + (exists ((a/68 G_lprefix__neg)) + (and + (= (_select_LCons__1 (proj_G_lprefix__neg_2 a/60)) + (proj_G_lprefix__neg_2 a/68)) + (= (_select_LCons__1 (proj_G_lprefix__neg_1 a/60)) + (proj_G_lprefix__neg_1 a/68)) + (= (_select__succ_0 (proj_G_lprefix__neg_0 a/60)) + (proj_G_lprefix__neg_0 a/68)))) + (lprefix__- (_select__succ_0 (proj_G_lprefix__neg_0 a/60)) + (_select_LCons__1 (proj_G_lprefix__neg_1 a/60)) + (_select_LCons__1 (proj_G_lprefix__neg_2 a/60)))) + (is-_succ (proj_G_lprefix__neg_0 a/60)) + (is-LCons_ (proj_G_lprefix__neg_1 a/60)) + (is-LCons_ (proj_G_lprefix__neg_2 a/60)) + (= (_select_LCons__0 (proj_G_lprefix__neg_2 a/60)) + (_select_LCons__0 (proj_G_lprefix__neg_1 a/60))))) + (lprefix__- (proj_G_lprefix__neg_0 a/60) (proj_G_lprefix__neg_1 a/60) + (proj_G_lprefix__neg_2 a/60))))) +(declare-sort G_lprefix__pos 0) +(declare-fun __nun_card_witness_2 () G_lprefix__pos) +(declare-fun lprefix__+ (llist_ llist_) Bool) +(declare-fun proj_G_lprefix__pos_0 (G_lprefix__pos) llist_) +(declare-fun proj_G_lprefix__pos_1 (G_lprefix__pos) llist_) +(assert + (forall ((a/69 G_lprefix__pos)) + (=> + (lprefix__+ (proj_G_lprefix__pos_0 a/69) (proj_G_lprefix__pos_1 a/69)) + (or (= (proj_G_lprefix__pos_0 a/69) LNil_) + (and + (lprefix__+ (_select_LCons__1 (proj_G_lprefix__pos_0 a/69)) + (_select_LCons__1 (proj_G_lprefix__pos_1 a/69))) + (exists ((a/77 G_lprefix__pos)) + (and + (= (_select_LCons__1 (proj_G_lprefix__pos_1 a/69)) + (proj_G_lprefix__pos_1 a/77)) + (= (_select_LCons__1 (proj_G_lprefix__pos_0 a/69)) + (proj_G_lprefix__pos_0 a/77)))) + (is-LCons_ (proj_G_lprefix__pos_0 a/69)) + (is-LCons_ (proj_G_lprefix__pos_1 a/69)) + (= (_select_LCons__0 (proj_G_lprefix__pos_1 a/69)) + (_select_LCons__0 (proj_G_lprefix__pos_0 a/69)))))))) +(declare-fun nun_sk_0 () llist_) +(assert + (or + (and + (not + (=> + (exists ((a/109 G_lprefix__neg)) + (and (= (LCons_ y_ ys_) (proj_G_lprefix__neg_2 a/109)) + (= xs_ (proj_G_lprefix__neg_1 a/109)) + (= decr_lprefix_ (proj_G_lprefix__neg_0 a/109)))) + (lprefix__- decr_lprefix_ xs_ (LCons_ y_ ys_)))) + (or (= xs_ LNil_) + (and (= xs_ (LCons_ y_ nun_sk_0)) (lprefix__+ xs_ ys_) + (exists ((a/113 G_lprefix__pos)) + (and (= ys_ (proj_G_lprefix__pos_1 a/113)) + (= xs_ (proj_G_lprefix__pos_0 a/113))))))) + (and (not (= xs_ LNil_)) + (forall ((xs_H_/120 llist_)) + (or (not (= xs_ (LCons_ y_ xs_H_/120))) + (not + (=> + (exists ((a/124 G_lprefix__neg)) + (and (= ys_ (proj_G_lprefix__neg_2 a/124)) + (= xs_ (proj_G_lprefix__neg_1 a/124)) + (= decr_lprefix_ (proj_G_lprefix__neg_0 a/124)))) + (lprefix__- decr_lprefix_ xs_ ys_))))) + (lprefix__+ xs_ (LCons_ y_ ys_)) + (exists ((a/125 G_lprefix__pos)) + (and (= (LCons_ y_ ys_) (proj_G_lprefix__pos_1 a/125)) + (= xs_ (proj_G_lprefix__pos_0 a/125))))))) +(check-sat) diff --git a/test/regress/regress1/fmf/ko-bound-set.cvc b/test/regress/regress1/fmf/ko-bound-set.cvc new file mode 100644 index 000000000..eebcbc2f8 --- /dev/null +++ b/test/regress/regress1/fmf/ko-bound-set.cvc @@ -0,0 +1,10 @@ +% EXPECT: invalid +OPTION "finite-model-find"; +OPTION "fmf-bound-int"; +OPTION "produce-models"; + +X, Y : SET OF INT; + +ASSERT FORALL(x : INT): x IS_IN X => x > 0; +QUERY ||X|| = 5 AND Y = X | {9} => ||Y|| <= 4; + diff --git a/test/regress/regress1/fmf/loopy_coda.smt2 b/test/regress/regress1/fmf/loopy_coda.smt2 new file mode 100644 index 000000000..519fb17fc --- /dev/null +++ b/test/regress/regress1/fmf/loopy_coda.smt2 @@ -0,0 +1,38 @@ +; COMMAND-LINE: --finite-model-find --fmf-inst-engine --uf-ss-fair-monotone --lang=smt2.5 +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(declare-sort a 0) +(declare-fun __nun_card_witness_0 () a) +(declare-codatatypes () + ((llist (LCons (_select_LCons_0 a) (_select_LCons_1 llist)) (LNil )))) +(declare-fun xs () llist) +(declare-fun y () a) +(declare-fun ys () llist) +(declare-sort G_lappend 0) +(declare-fun __nun_card_witness_1 () G_lappend) +(declare-fun lappend (llist llist) llist) +(declare-fun proj_G_lappend_0 (G_lappend) llist) +(declare-fun proj_G_lappend_1 (G_lappend) llist) +(assert + (forall ((a/33 G_lappend)) + (and + (= (lappend (proj_G_lappend_0 a/33) (proj_G_lappend_1 a/33)) + (ite (is-LCons (proj_G_lappend_0 a/33)) + (LCons (_select_LCons_0 (proj_G_lappend_0 a/33)) + (lappend (_select_LCons_1 (proj_G_lappend_0 a/33)) + (proj_G_lappend_1 a/33))) + (proj_G_lappend_1 a/33))) + (=> (is-LCons (proj_G_lappend_0 a/33)) + (exists ((a/35 G_lappend)) + (and (= (proj_G_lappend_1 a/33) (proj_G_lappend_1 a/35)) + (= (_select_LCons_1 (proj_G_lappend_0 a/33)) + (proj_G_lappend_0 a/35)))))))) +(assert + (not + (=> + (exists ((a/37 G_lappend)) + (and (= (LCons y ys) (proj_G_lappend_1 a/37)) + (= xs (proj_G_lappend_0 a/37)))) + (= (lappend xs (LCons y ys)) xs)))) +(check-sat) diff --git a/test/regress/regress1/fmf/lst-no-self-rev-exp.smt2 b/test/regress/regress1/fmf/lst-no-self-rev-exp.smt2 new file mode 100644 index 000000000..d55e15925 --- /dev/null +++ b/test/regress/regress1/fmf/lst-no-self-rev-exp.smt2 @@ -0,0 +1,35 @@ +; COMMAND-LINE: --finite-model-find --dt-rewrite-error-sel --lang=smt2.5 +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(declare-datatypes () ((Nat (succ (pred Nat)) (zero)) (Lst (cons (hd Nat) (tl Lst)) (nil)))) + +(declare-fun app (Lst Lst) Lst) +(declare-fun rev (Lst) Lst) + +(declare-sort I_app 0) +(declare-sort I_rev 0) + +(declare-fun a () I_app) +(declare-fun b () I_app) +(assert (not (= a b))) + +(declare-fun app_0_3 (I_app) Lst) +(declare-fun app_1_4 (I_app) Lst) +(declare-fun rev_0_5 (I_rev) Lst) + +(declare-fun xs () Lst) + +(assert (and + +(forall ((?i I_app)) (= (app (app_0_3 ?i) (app_1_4 ?i)) (ite (is-cons (app_0_3 ?i)) (cons (hd (app_0_3 ?i)) (app (tl (app_0_3 ?i)) (app_1_4 ?i))) (app_1_4 ?i))) ) + +(forall ((?i I_rev)) (= (rev (rev_0_5 ?i)) (ite (is-cons (rev_0_5 ?i)) (app (rev (tl (rev_0_5 ?i))) (cons (hd (rev_0_5 ?i)) nil)) nil)) ) + +(forall ((?i I_rev)) (or (not (is-cons (rev_0_5 ?i))) (and (not (forall ((?z I_app)) (not (and (= (app_0_3 ?z) (rev (tl (rev_0_5 ?i)))) (= (app_1_4 ?z) (cons (hd (rev_0_5 ?i)) nil)))) )) (not (forall ((?z I_rev)) (not (= (rev_0_5 ?z) (tl (rev_0_5 ?i)) )) )))) ) + +(not (or (= xs (rev xs)) (forall ((?z I_rev)) (not (= (rev_0_5 ?z) xs)) ))) + +)) + +(check-sat) + diff --git a/test/regress/regress1/fmf/memory_model-R_cpp-dd.cvc b/test/regress/regress1/fmf/memory_model-R_cpp-dd.cvc new file mode 100644 index 000000000..5d1289997 --- /dev/null +++ b/test/regress/regress1/fmf/memory_model-R_cpp-dd.cvc @@ -0,0 +1,52 @@ +% EXPECT: sat +OPTION "produce-models"; +OPTION "fmf-bound"; + +DATATYPE MOPERATION = R | W | M END; +DATATYPE ORDER = I | SC | U END; +DATATYPE ATOM = AT | NA END; + +DATATYPE BINT = I0 | I1 | I2 | I3 END; + +DATATYPE TEAR_TYPE = TEAR_TRUE | TEAR_FALSE END; +SDBLOCK_TYPE: TYPE; +VALUE_TYPE: TYPE; +ADDRESS_TYPE: TYPE = SET OF BINT; + +MEM_OP_TYPE : TYPE = [# O:MOPERATION, T:TEAR_TYPE, R:ORDER, A:ATOM, B:SDBLOCK_TYPE, M:ADDRESS_TYPE, V:VALUE_TYPE #]; +EV_REL: TYPE = SET OF [MEM_OP_TYPE, MEM_OP_TYPE]; +THREAD_TYPE : TYPE = [# E:SET OF MEM_OP_TYPE, PO:EV_REL #]; + +m1 : SDBLOCK_TYPE; + +ow1 : MEM_OP_TYPE; +or2 : MEM_OP_TYPE; + +v1 : VALUE_TYPE; +v2 : VALUE_TYPE; + +ASSERT (ow1.O = W) AND + (ow1.T = TEAR_FALSE) AND + (ow1.R = U) AND + (ow1.A = NA) AND + (ow1.B = m1) AND + (ow1.M = {I0}) AND + (ow1.V = v1); + +ASSERT (or2.O = R) AND + (or2.T = TEAR_FALSE) AND + (or2.R = U) AND + (or2.A = NA) AND + (or2.B = m1) AND + (or2.M = {I0}) AND + (or2.V = v2); + +ev_set : SET OF MEM_OP_TYPE; + +ASSERT ev_set = {ow1, or2}; + +RF : EV_REL; + +ASSERT FORALL (r,w: MEM_OP_TYPE) : (((r IS_IN ev_set) AND (w IS_IN ev_set)) => (((r,w) IS_IN RF) <=> ((r.O = R) AND (w.O = W)))); + +CHECKSAT; diff --git a/test/regress/regress1/fmf/nun-0208-to.smt2 b/test/regress/regress1/fmf/nun-0208-to.smt2 new file mode 100644 index 000000000..e6b3c2021 --- /dev/null +++ b/test/regress/regress1/fmf/nun-0208-to.smt2 @@ -0,0 +1,180 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: sat + (set-logic ALL_SUPPORTED) + (declare-sort b__ 0) + (declare-fun __nun_card_witness_0_ () b__) + (declare-sort a__ 0) + (declare-fun __nun_card_witness_1_ () a__) + (declare-datatypes () + ((prod__ (Pair__ (_select_Pair___0 a__) (_select_Pair___1 b__))))) + (declare-datatypes () + ((list2__ + (Cons2__ (_select_Cons2___0 prod__) (_select_Cons2___1 list2__)) + (Nil2__ )))) + (declare-datatypes () + ((list__ (Cons__ (_select_Cons___0 a__) (_select_Cons___1 list__)) + (Nil__ )))) + (declare-datatypes () + ((list1__ (Cons1__ (_select_Cons1___0 b__) (_select_Cons1___1 list1__)) + (Nil1__ )))) + (declare-sort G_zip__ 0) + (declare-fun __nun_card_witness_2_ () G_zip__) + (declare-fun zip__ (list__ list1__) list2__) + (declare-fun proj_G_zip__0_ (G_zip__) list__) + (declare-fun proj_G_zip__1_ (G_zip__) list1__) + (assert + (forall ((a/166 G_zip__)) + (and + (= (zip__ (proj_G_zip__0_ a/166) (proj_G_zip__1_ a/166)) + (ite (is-Cons1__ (proj_G_zip__1_ a/166)) + (ite (is-Cons__ (proj_G_zip__0_ a/166)) + (Cons2__ + (Pair__ (_select_Cons___0 (proj_G_zip__0_ a/166)) + (_select_Cons1___0 (proj_G_zip__1_ a/166))) + (zip__ (_select_Cons___1 (proj_G_zip__0_ a/166)) + (_select_Cons1___1 (proj_G_zip__1_ a/166)))) + Nil2__) + Nil2__)) + (=> (is-Cons1__ (proj_G_zip__1_ a/166)) + (=> (is-Cons__ (proj_G_zip__0_ a/166)) + (exists ((a/168 G_zip__)) + (and + (= (_select_Cons1___1 (proj_G_zip__1_ a/166)) + (proj_G_zip__1_ a/168)) + (= (_select_Cons___1 (proj_G_zip__0_ a/166)) + (proj_G_zip__0_ a/168))))))))) + (declare-datatypes () ((nat__ (Suc__ (_select_Suc___0 nat__)) (zero__ )))) + (declare-sort G_replicate__ 0) + (declare-fun __nun_card_witness_3_ () G_replicate__) + (declare-fun replicate__ (nat__ a__) list__) + (declare-fun proj_G_replicate__0_ (G_replicate__) nat__) + (declare-fun proj_G_replicate__1_ (G_replicate__) a__) + (assert + (forall ((a/169 G_replicate__)) + (and + (= + (replicate__ (proj_G_replicate__0_ a/169) + (proj_G_replicate__1_ a/169)) + (ite (is-Suc__ (proj_G_replicate__0_ a/169)) + (Cons__ (proj_G_replicate__1_ a/169) + (replicate__ (_select_Suc___0 (proj_G_replicate__0_ a/169)) + (proj_G_replicate__1_ a/169))) + Nil__)) + (=> (is-Suc__ (proj_G_replicate__0_ a/169)) + (exists ((a/171 G_replicate__)) + (and + (= (proj_G_replicate__1_ a/169) (proj_G_replicate__1_ a/171)) + (= (_select_Suc___0 (proj_G_replicate__0_ a/169)) + (proj_G_replicate__0_ a/171)))))))) + (declare-fun j__ () nat__) + (declare-fun x__ () a__) + (declare-sort G_replicate1__ 0) + (declare-fun __nun_card_witness_4_ () G_replicate1__) + (declare-fun replicate1__ (nat__ b__) list1__) + (declare-fun proj_G_replicate1__0_ (G_replicate1__) nat__) + (declare-fun proj_G_replicate1__1_ (G_replicate1__) b__) + (assert + (forall ((a/172 G_replicate1__)) + (and + (= + (replicate1__ (proj_G_replicate1__0_ a/172) + (proj_G_replicate1__1_ a/172)) + (ite (is-Suc__ (proj_G_replicate1__0_ a/172)) + (Cons1__ (proj_G_replicate1__1_ a/172) + (replicate1__ (_select_Suc___0 (proj_G_replicate1__0_ a/172)) + (proj_G_replicate1__1_ a/172))) + Nil1__)) + (=> (is-Suc__ (proj_G_replicate1__0_ a/172)) + (exists ((a/174 G_replicate1__)) + (and + (= (proj_G_replicate1__1_ a/172) (proj_G_replicate1__1_ a/174)) + (= (_select_Suc___0 (proj_G_replicate1__0_ a/172)) + (proj_G_replicate1__0_ a/174)))))))) + (declare-fun y__ () b__) + (declare-sort G_replicate2__ 0) + (declare-fun __nun_card_witness_5_ () G_replicate2__) + (declare-fun replicate2__ (nat__ prod__) list2__) + (declare-fun proj_G_replicate2__0_ (G_replicate2__) nat__) + (declare-fun proj_G_replicate2__1_ (G_replicate2__) prod__) + (assert + (forall ((a/175 G_replicate2__)) + (and + (= + (replicate2__ (proj_G_replicate2__0_ a/175) + (proj_G_replicate2__1_ a/175)) + (ite (is-Suc__ (proj_G_replicate2__0_ a/175)) + (Cons2__ (proj_G_replicate2__1_ a/175) + (replicate2__ (_select_Suc___0 (proj_G_replicate2__0_ a/175)) + (proj_G_replicate2__1_ a/175))) + Nil2__)) + (=> (is-Suc__ (proj_G_replicate2__0_ a/175)) + (exists ((a/177 G_replicate2__)) + (and + (= (proj_G_replicate2__1_ a/175) (proj_G_replicate2__1_ a/177)) + (= (_select_Suc___0 (proj_G_replicate2__0_ a/175)) + (proj_G_replicate2__0_ a/177)))))))) + (declare-sort G_less__eq__ 0) + (declare-fun __nun_card_witness_6_ () G_less__eq__) + (declare-fun less__eq__ (nat__ nat__) Bool) + (declare-fun proj_G_less__eq__0_ (G_less__eq__) nat__) + (declare-fun proj_G_less__eq__1_ (G_less__eq__) nat__) + (assert + (forall ((a/178 G_less__eq__)) + (and + (= + (less__eq__ (proj_G_less__eq__0_ a/178) (proj_G_less__eq__1_ a/178)) + (=> (is-Suc__ (proj_G_less__eq__0_ a/178)) + (and (is-Suc__ (proj_G_less__eq__1_ a/178)) + (less__eq__ (_select_Suc___0 (proj_G_less__eq__0_ a/178)) + (_select_Suc___0 (proj_G_less__eq__1_ a/178)))))) + (exists ((a/182 G_less__eq__)) + (and + (= (_select_Suc___0 (proj_G_less__eq__1_ a/178)) + (proj_G_less__eq__1_ a/182)) + (= (_select_Suc___0 (proj_G_less__eq__0_ a/178)) + (proj_G_less__eq__0_ a/182))))))) + (declare-sort G_min__ 0) + (declare-fun __nun_card_witness_7_ () G_min__) + (declare-fun min__ (nat__ nat__) nat__) + (declare-fun proj_G_min__0_ (G_min__) nat__) + (declare-fun proj_G_min__1_ (G_min__) nat__) + (assert + (forall ((a/183 G_min__)) + (and + (= (min__ (proj_G_min__0_ a/183) (proj_G_min__1_ a/183)) + (ite (less__eq__ (proj_G_min__0_ a/183) (proj_G_min__1_ a/183)) + (proj_G_min__0_ a/183) (proj_G_min__1_ a/183))) + (exists ((a/184 G_less__eq__)) + (and (= (proj_G_min__1_ a/183) (proj_G_less__eq__1_ a/184)) + (= (proj_G_min__0_ a/183) (proj_G_less__eq__0_ a/184))))))) + (declare-fun i__ () nat__) + (assert + (not + (=> + (and + (exists ((a/212 G_min__)) + (and (= i__ (proj_G_min__1_ a/212)) (= i__ (proj_G_min__0_ a/212)))) + (exists ((a/208 G_replicate2__)) + (and (= (Pair__ x__ y__) (proj_G_replicate2__1_ a/208)) + (= (min__ i__ i__) (proj_G_replicate2__0_ a/208)) + (exists ((a/210 G_min__)) + (and (= i__ (proj_G_min__1_ a/210)) + (= i__ (proj_G_min__0_ a/210)))))) + (exists ((a/199 G_zip__)) + (and (= (replicate1__ j__ y__) (proj_G_zip__1_ a/199)) + (exists ((a/202 G_replicate1__)) + (and (= y__ (proj_G_replicate1__1_ a/202)) + (= j__ (proj_G_replicate1__0_ a/202)))) + (= (replicate__ j__ x__) (proj_G_zip__0_ a/199)) + (exists ((a/203 G_replicate__)) + (and (= x__ (proj_G_replicate__1_ a/203)) + (= j__ (proj_G_replicate__0_ a/203)))))) + (exists ((a/207 G_replicate1__)) + (and (= y__ (proj_G_replicate1__1_ a/207)) + (= j__ (proj_G_replicate1__0_ a/207)))) + (exists ((a/206 G_replicate__)) + (and (= x__ (proj_G_replicate__1_ a/206)) + (= j__ (proj_G_replicate__0_ a/206))))) + (= (replicate2__ (min__ i__ i__) (Pair__ x__ y__)) + (zip__ (replicate__ j__ x__) (replicate1__ j__ y__)))))) + (check-sat) diff --git a/test/regress/regress1/fmf/nunchaku2309663.nun.min.smt2 b/test/regress/regress1/fmf/nunchaku2309663.nun.min.smt2 deleted file mode 100644 index 9c8bc1d3e..000000000 --- a/test/regress/regress1/fmf/nunchaku2309663.nun.min.smt2 +++ /dev/null @@ -1,79 +0,0 @@ -; EXPECT: unsat -; COMMAND-LINE: --finite-model-find --lang=smt2.5 -(set-logic ALL_SUPPORTED) -(set-info :status unsat) -(declare-datatypes () ((nat__ (Suc__ (_select_Suc___0 nat__)) (zero__ )))) -(declare-sort a__ 0) -(declare-fun __nun_card_witness_0_ () a__) -(declare-datatypes () - ((tree__ - (MKT__ (_select_MKT___0 a__) (_select_MKT___1 tree__) - (_select_MKT___2 tree__) (_select_MKT___3 nat__)) - (ET__ )))) -(declare-sort G_plus__ 0) -(declare-fun __nun_card_witness_1_ () G_plus__) -(declare-fun plus__ (nat__ nat__) nat__) -(declare-fun proj_G_plus__0_ (G_plus__) nat__) -(declare-fun proj_G_plus__1_ (G_plus__) nat__) - -(declare-sort G_less__eq__ 0) -(declare-fun __nun_card_witness_2_ () G_less__eq__) -(declare-fun less__eq__ (nat__ nat__) Bool) -(declare-fun proj_G_less__eq__0_ (G_less__eq__) nat__) -(declare-fun proj_G_less__eq__1_ (G_less__eq__) nat__) - -(declare-sort G_max__ 0) -(declare-fun __nun_card_witness_3_ () G_max__) -(declare-fun max__ (nat__ nat__) nat__) -(declare-fun proj_G_max__0_ (G_max__) nat__) -(declare-fun proj_G_max__1_ (G_max__) nat__) - -(declare-sort G_one__ 0) -(declare-fun __nun_card_witness_4_ () G_one__) -(declare-fun one__ () nat__) -(assert (forall ((a/295 G_one__)) (= one__ (Suc__ zero__)))) -(declare-sort G_height__ 0) -(declare-fun __nun_card_witness_5_ () G_height__) -(declare-fun height__ (tree__) nat__) -(declare-fun proj_G_height__0_ (G_height__) tree__) - -(declare-sort G_avl__ 0) -(declare-fun __nun_card_witness_6_ () G_avl__) -(declare-fun avl__ (tree__) Bool) -(declare-fun proj_G_avl__0_ (G_avl__) tree__) - -(declare-fun l__ () tree__) -(declare-fun r__ () tree__) -(declare-sort G_minus__ 0) -(declare-fun __nun_card_witness_7_ () G_minus__) -(declare-fun minus__ (Bool Bool) Bool) -(declare-fun proj_G_minus__0_ (G_minus__) Bool) -(declare-fun proj_G_minus__1_ (G_minus__) Bool) - -(declare-sort G_ht__ 0) -(declare-fun __nun_card_witness_8_ () G_ht__) -(declare-fun ht__ (tree__) nat__) -(declare-fun proj_G_ht__0_ (G_ht__) tree__) - -(declare-sort G_mkt__ 0) -(declare-fun __nun_card_witness_9_ () G_mkt__) -(declare-fun mkt__ (a__ tree__ tree__) tree__) -(declare-fun proj_G_mkt__0_ (G_mkt__) a__) -(declare-fun proj_G_mkt__1_ (G_mkt__) tree__) -(declare-fun proj_G_mkt__2_ (G_mkt__) tree__) - -(declare-fun x__ () a__) - -(assert (and -(forall ((a/334 G_avl__)) (and (= (avl__ (proj_G_avl__0_ a/334)) (=> (is-MKT__ (proj_G_avl__0_ a/334)) (and (or (= (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (height__ (_select_MKT___2 (proj_G_avl__0_ a/334)))) (= (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (plus__ (height__ (_select_MKT___2 (proj_G_avl__0_ a/334))) one__)) (= (height__ (_select_MKT___2 (proj_G_avl__0_ a/334))) (plus__ (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) one__))) (= (_select_MKT___3 (proj_G_avl__0_ a/334)) (plus__ (max__ (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (height__ (_select_MKT___2 (proj_G_avl__0_ a/334)))) one__)) (avl__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (avl__ (_select_MKT___2 (proj_G_avl__0_ a/334)))))) (exists ((a/602 G_avl__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_avl__0_ a/602)) ) (exists ((a/601 G_avl__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_avl__0_ a/601)) ) (exists ((a/592 G_max__)) (and (= (height__ (_select_MKT___2 (proj_G_avl__0_ a/334))) (proj_G_max__1_ a/592)) (exists ((a/595 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/595)) ) (= (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (proj_G_max__0_ a/592)) (exists ((a/596 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/596)) )) ) (exists ((a/600 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/600)) ) (exists ((a/599 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/599)) ) (exists ((a/564 G_plus__)) (and (= one__ (proj_G_plus__1_ a/564)) (= (max__ (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (height__ (_select_MKT___2 (proj_G_avl__0_ a/334)))) (proj_G_plus__0_ a/564)) (exists ((a/581 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/581)) ) (exists ((a/582 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/582)) ) (exists ((a/574 G_max__)) (and (= (height__ (_select_MKT___2 (proj_G_avl__0_ a/334))) (proj_G_max__1_ a/574)) (exists ((a/577 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/577)) ) (= (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (proj_G_max__0_ a/574)) (exists ((a/578 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/578)) )) )) ) (exists ((a/551 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/551)) ) (exists ((a/550 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/550)) ) (exists ((a/557 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/557)) ) (exists ((a/552 G_plus__)) (and (= one__ (proj_G_plus__1_ a/552)) (= (height__ (_select_MKT___2 (proj_G_avl__0_ a/334))) (proj_G_plus__0_ a/552)) (exists ((a/554 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/554)) )) ) (exists ((a/556 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/556)) ) (exists ((a/563 G_height__)) (= (_select_MKT___2 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/563)) ) (exists ((a/558 G_plus__)) (and (= one__ (proj_G_plus__1_ a/558)) (= (height__ (_select_MKT___1 (proj_G_avl__0_ a/334))) (proj_G_plus__0_ a/558)) (exists ((a/560 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/560)) )) ) (exists ((a/562 G_height__)) (= (_select_MKT___1 (proj_G_avl__0_ a/334)) (proj_G_height__0_ a/562)) )) ) -(forall ((a/603 G_minus__)) (= (minus__ (proj_G_minus__0_ a/603) (proj_G_minus__1_ a/603)) (ite (proj_G_minus__0_ a/603) (ite (proj_G_minus__1_ a/603) (and (proj_G_minus__0_ a/603) (not (proj_G_minus__1_ a/603))) (and (proj_G_minus__0_ a/603) (not (proj_G_minus__1_ a/603)))) (ite (proj_G_minus__1_ a/603) (and (proj_G_minus__0_ a/603) (not (proj_G_minus__1_ a/603))) (and (proj_G_minus__0_ a/603) (not (proj_G_minus__1_ a/603)))))) ) -(forall ((a/296 G_height__)) (and (= (height__ (proj_G_height__0_ a/296)) (ite (is-MKT__ (proj_G_height__0_ a/296)) (plus__ (max__ (height__ (_select_MKT___1 (proj_G_height__0_ a/296))) (height__ (_select_MKT___2 (proj_G_height__0_ a/296)))) one__) zero__)) (=> (is-MKT__ (proj_G_height__0_ a/296)) (and (exists ((a/297 G_plus__)) (and (= one__ (proj_G_plus__1_ a/297)) (= (max__ (height__ (_select_MKT___1 (proj_G_height__0_ a/296))) (height__ (_select_MKT___2 (proj_G_height__0_ a/296)))) (proj_G_plus__0_ a/297)) (exists ((a/314 G_height__)) (= (_select_MKT___1 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/314)) ) (exists ((a/315 G_height__)) (= (_select_MKT___2 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/315)) ) (exists ((a/307 G_max__)) (and (= (height__ (_select_MKT___2 (proj_G_height__0_ a/296))) (proj_G_max__1_ a/307)) (exists ((a/310 G_height__)) (= (_select_MKT___2 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/310)) ) (= (height__ (_select_MKT___1 (proj_G_height__0_ a/296))) (proj_G_max__0_ a/307)) (exists ((a/311 G_height__)) (= (_select_MKT___1 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/311)) )) )) ) (exists ((a/332 G_height__)) (= (_select_MKT___1 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/332)) ) (exists ((a/333 G_height__)) (= (_select_MKT___2 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/333)) ) (exists ((a/325 G_max__)) (and (= (height__ (_select_MKT___2 (proj_G_height__0_ a/296))) (proj_G_max__1_ a/325)) (exists ((a/328 G_height__)) (= (_select_MKT___2 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/328)) ) (= (height__ (_select_MKT___1 (proj_G_height__0_ a/296))) (proj_G_max__0_ a/325)) (exists ((a/329 G_height__)) (= (_select_MKT___1 (proj_G_height__0_ a/296)) (proj_G_height__0_ a/329)) )) )))) ) -(forall ((a/604 G_ht__)) (= (ht__ (proj_G_ht__0_ a/604)) (ite (is-MKT__ (proj_G_ht__0_ a/604)) (_select_MKT___3 (proj_G_ht__0_ a/604)) zero__)) ) - -(not (=> (and (avl__ l__) (exists ((a/1961 G_avl__)) (= l__ (proj_G_avl__0_ a/1961)) )) (=> (and (avl__ r__) (exists ((a/2175 G_avl__)) (= r__ (proj_G_avl__0_ a/2175)) )) (=> (or (and (= (height__ l__) (height__ r__)) (exists ((a/2334 G_height__)) (= l__ (proj_G_height__0_ a/2334)) ) (exists ((a/2333 G_height__)) (= r__ (proj_G_height__0_ a/2333)) )) (and (minus__ (= (height__ l__) (plus__ (height__ r__) one__)) (= (height__ r__) (plus__ (height__ l__) one__))) (exists ((a/2382 G_height__)) (= l__ (proj_G_height__0_ a/2382)) ) (exists ((a/2378 G_plus__)) (and (= one__ (proj_G_plus__1_ a/2378)) (= (height__ l__) (proj_G_plus__0_ a/2378)) (exists ((a/2380 G_height__)) (= l__ (proj_G_height__0_ a/2380)) )) ) (exists ((a/2383 G_height__)) (= r__ (proj_G_height__0_ a/2383)) ) (exists ((a/2376 G_height__)) (= r__ (proj_G_height__0_ a/2376)) ) (exists ((a/2372 G_plus__)) (and (= one__ (proj_G_plus__1_ a/2372)) (= (height__ r__) (proj_G_plus__0_ a/2372)) (exists ((a/2374 G_height__)) (= r__ (proj_G_height__0_ a/2374)) )) ) (exists ((a/2377 G_height__)) (= l__ (proj_G_height__0_ a/2377)) ) (exists ((a/2335 G_minus__)) (and (= (= (height__ r__) (plus__ (height__ l__) one__)) (proj_G_minus__1_ a/2335)) (exists ((a/2352 G_height__)) (= l__ (proj_G_height__0_ a/2352)) ) (exists ((a/2348 G_plus__)) (and (= one__ (proj_G_plus__1_ a/2348)) (= (height__ l__) (proj_G_plus__0_ a/2348)) (exists ((a/2350 G_height__)) (= l__ (proj_G_height__0_ a/2350)) )) ) (exists ((a/2353 G_height__)) (= r__ (proj_G_height__0_ a/2353)) ) (= (= (height__ l__) (plus__ (height__ r__) one__)) (proj_G_minus__0_ a/2335)) (exists ((a/2358 G_height__)) (= r__ (proj_G_height__0_ a/2358)) ) (exists ((a/2354 G_plus__)) (and (= one__ (proj_G_plus__1_ a/2354)) (= (height__ r__) (proj_G_plus__0_ a/2354)) (exists ((a/2356 G_height__)) (= r__ (proj_G_height__0_ a/2356)) )) ) (exists ((a/2359 G_height__)) (= l__ (proj_G_height__0_ a/2359)) )) ))) (=> (exists ((a/2384 G_avl__)) (and (= (mkt__ x__ l__ r__) (proj_G_avl__0_ a/2384)) (exists ((a/2385 G_mkt__)) (and (= r__ (proj_G_mkt__2_ a/2385)) (= l__ (proj_G_mkt__1_ a/2385)) (= x__ (proj_G_mkt__0_ a/2385))) )) ) (=> (exists ((a/2387 G_mkt__)) (and (= r__ (proj_G_mkt__2_ a/2387)) (= l__ (proj_G_mkt__1_ a/2387)) (= x__ (proj_G_mkt__0_ a/2387))) ) (avl__ (mkt__ x__ l__ r__)))))))) -(forall ((a/605 G_mkt__)) (and (= (mkt__ (proj_G_mkt__0_ a/605) (proj_G_mkt__1_ a/605) (proj_G_mkt__2_ a/605)) (MKT__ (proj_G_mkt__0_ a/605) (proj_G_mkt__1_ a/605) (proj_G_mkt__2_ a/605) (plus__ (max__ (ht__ (proj_G_mkt__1_ a/605)) (ht__ (proj_G_mkt__2_ a/605))) one__))) (exists ((a/671 G_max__)) (and (= (ht__ (proj_G_mkt__2_ a/605)) (proj_G_max__1_ a/671)) (exists ((a/674 G_ht__)) (= (proj_G_mkt__2_ a/605) (proj_G_ht__0_ a/674)) ) (= (ht__ (proj_G_mkt__1_ a/605)) (proj_G_max__0_ a/671)) (exists ((a/675 G_ht__)) (= (proj_G_mkt__1_ a/605) (proj_G_ht__0_ a/675)) )) ) (exists ((a/679 G_ht__)) (= (proj_G_mkt__2_ a/605) (proj_G_ht__0_ a/679)) ) (exists ((a/678 G_ht__)) (= (proj_G_mkt__1_ a/605) (proj_G_ht__0_ a/678)) ) (exists ((a/643 G_plus__)) (and (= one__ (proj_G_plus__1_ a/643)) (= (max__ (ht__ (proj_G_mkt__1_ a/605)) (ht__ (proj_G_mkt__2_ a/605))) (proj_G_plus__0_ a/643)) (exists ((a/660 G_ht__)) (= (proj_G_mkt__1_ a/605) (proj_G_ht__0_ a/660)) ) (exists ((a/661 G_ht__)) (= (proj_G_mkt__2_ a/605) (proj_G_ht__0_ a/661)) ) (exists ((a/653 G_max__)) (and (= (ht__ (proj_G_mkt__2_ a/605)) (proj_G_max__1_ a/653)) (exists ((a/656 G_ht__)) (= (proj_G_mkt__2_ a/605) (proj_G_ht__0_ a/656)) ) (= (ht__ (proj_G_mkt__1_ a/605)) (proj_G_max__0_ a/653)) (exists ((a/657 G_ht__)) (= (proj_G_mkt__1_ a/605) (proj_G_ht__0_ a/657)) )) )) )) ) -(forall ((a/295 G_one__)) (= one__ (Suc__ zero__)) ) - -)) - -(check-sat) diff --git a/test/regress/regress1/fmf/pow2-bool.smt2 b/test/regress/regress1/fmf/pow2-bool.smt2 new file mode 100644 index 000000000..4943c646c --- /dev/null +++ b/test/regress/regress1/fmf/pow2-bool.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --fmf-fun --no-check-models +; EXPECT: sat +(set-logic ALL) + +(define-fun-rec pow2 ((n Int) (p Int)) Bool ( + or + (and (= n 0) (= p 1)) + (and (> n 0) (> p 1) (= 0 (mod p 2)) (pow2 (- n 1) (div p 2))) +)) + +(declare-const n Int) +(declare-const p Int) + +(assert (= n 10)) +(assert (pow2 n p)) + +(check-sat) diff --git a/test/regress/regress1/fmf/refcount24.cvc.smt2 b/test/regress/regress1/fmf/refcount24.cvc.smt2 new file mode 100644 index 000000000..e3b6957d0 --- /dev/null +++ b/test/regress/regress1/fmf/refcount24.cvc.smt2 @@ -0,0 +1,37 @@ +; COMMAND-LINE: --finite-model-find +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(set-info :smt-lib-version 2.0) +(set-info :category "unknown") +(set-info :status sat) +(declare-datatypes () +((UNIT (Unit)) +)) +(declare-datatypes () +((BOOL (Truth) (Falsity)) +)) +(declare-sort resource$type 0) +(declare-sort process$type 0) +(declare-fun null () resource$type) +(declare-sort S$t$type 0) +(declare-fun S$empty () S$t$type) +(declare-fun S$mem (process$type S$t$type) BOOL) +(declare-fun S$add (process$type S$t$type) S$t$type) +(declare-fun S$remove (process$type S$t$type) S$t$type) +(declare-fun S$cardinality (S$t$type) Int) +(assert (forall ((e process$type)) (not (= (S$mem e S$empty) Truth)))) +(assert (forall ((x process$type) (y process$type) (s S$t$type)) (= (S$mem x (S$add y s)) (ite (or (= x y) (= (S$mem x s) Truth)) Truth Falsity)))) +(assert (forall ((x process$type) (y process$type) (s S$t$type)) (= (S$mem x (S$remove y s)) (ite (and (not (= x y)) (= (S$mem x s) Truth)) Truth Falsity)))) +(assert (= (S$cardinality S$empty) 0)) +(assert (forall ((s S$t$type)) (=> (= (S$cardinality s) 0) (= s S$empty)))) +(assert (forall ((s S$t$type)) (>= (S$cardinality s) 0))) +(assert (forall ((x process$type) (s S$t$type)) (let ((?v_0 (S$cardinality s))) (= (S$cardinality (S$add x s)) (ite (= (S$mem x s) Truth) ?v_0 (+ ?v_0 1)))))) +(assert (forall ((x process$type) (s S$t$type)) (let ((?v_0 (S$cardinality s))) (= (S$cardinality (S$remove x s)) (ite (= (S$mem x s) Truth) (- ?v_0 1) ?v_0))))) +(declare-fun count () (Array resource$type Int)) +(declare-fun ref () (Array process$type resource$type)) +(declare-fun valid () (Array resource$type BOOL)) +(declare-fun destroy$r () resource$type) +(declare-fun valid$1 () (Array resource$type BOOL)) +(assert (not (=> (forall ((p process$type)) (let ((?v_0 (select ref p))) (=> (not (= ?v_0 null)) (= (select valid ?v_0) Truth)))) (=> (not (= destroy$r null)) (=> (= (select valid destroy$r) Truth) (=> (= (select count destroy$r) 0) (=> (= valid$1 (store valid destroy$r Falsity)) (forall ((p process$type)) (let ((?v_1 (select ref p))) (=> (not (= ?v_1 null)) (= (select valid$1 ?v_1) Truth))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/fmf/sc-crash-052316.smt2 b/test/regress/regress1/fmf/sc-crash-052316.smt2 new file mode 100644 index 000000000..345d8220e --- /dev/null +++ b/test/regress/regress1/fmf/sc-crash-052316.smt2 @@ -0,0 +1,35 @@ +; COMMAND-LINE: --finite-model-find --lang=smt2.5 +; EXPECT: unsat + (set-logic ALL_SUPPORTED) + (set-info :status unsat) + (declare-sort g_ 0) + (declare-fun __nun_card_witness_0_ () g_) + (declare-sort f_ 0) + (declare-fun __nun_card_witness_1_ () f_) + (declare-sort e_ 0) + (declare-fun __nun_card_witness_2_ () e_) +(declare-datatypes () + ((prod1_ (Pair1_ (_select_Pair1__0 e_) (_select_Pair1__1 f_))))) + (declare-sort d_ 0) + (declare-fun __nun_card_witness_3_ () d_) + (declare-sort c_ 0) + (declare-fun __nun_card_witness_4_ () c_) + (declare-sort b_ 0) + (declare-fun __nun_card_witness_5_ () b_) + (declare-sort a_ 0) + (declare-fun __nun_card_witness_6_ () a_) +(declare-datatypes () + ((prod_ (Pair_ (_select_Pair__0 a_) (_select_Pair__1 b_))))) + (declare-fun f1_ (prod_ c_ d_ prod1_) g_) + (declare-fun g1_ (prod_) c_) + (declare-fun h_ (prod_ d_) prod1_) + (declare-fun nun_sk_0_ () prod_) +(declare-fun nun_sk_1_ (c_) d_) + (assert + (not + (exists ((v/72 c_)) + (exists ((x/73 prod1_)) + (= (f1_ nun_sk_0_ v/72 (nun_sk_1_ v/72) x/73) + (f1_ nun_sk_0_ (g1_ nun_sk_0_) (nun_sk_1_ v/72) + (h_ nun_sk_0_ (nun_sk_1_ v/72)))))))) +(check-sat) diff --git a/test/regress/regress1/fmf/with-ind-104-core.smt2 b/test/regress/regress1/fmf/with-ind-104-core.smt2 new file mode 100644 index 000000000..c1d718403 --- /dev/null +++ b/test/regress/regress1/fmf/with-ind-104-core.smt2 @@ -0,0 +1,35 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-datatypes () ((Nat!2409 (succ!2410 (pred!2411 Nat!2409)) (zero!2412)) +)) +(declare-datatypes () ((Lst!2413 (cons!2414 (head!2415 Nat!2409) (tail!2416 Lst!2413)) (nil!2417)) +)) +(declare-fun error_value!2418 () Nat!2409) +(declare-fun plus!237 (Nat!2409 Nat!2409) Nat!2409) +(declare-fun error_value!2419 () Nat!2409) +(declare-fun count!263 (Nat!2409 Lst!2413) Nat!2409) +(declare-fun pred!2411_uf_1 (Nat!2409) Nat!2409) +(declare-fun tail!2416_uf_2 (Lst!2413) Lst!2413) +(declare-fun head!2415_uf_3 (Lst!2413) Nat!2409) +(declare-sort I_plus!237 0) +(set-info :notes "plus!237_arg_0_4 is op created during fun def fmf") +(declare-fun plus!237_arg_0_4 (I_plus!237) Nat!2409) +(set-info :notes "plus!237_arg_1_5 is op created during fun def fmf") +(declare-fun plus!237_arg_1_5 (I_plus!237) Nat!2409) +(declare-sort I_count!263 0) +(set-info :notes "count!263_arg_0_6 is op created during fun def fmf") +(declare-fun count!263_arg_0_6 (I_count!263) Nat!2409) +(set-info :notes "count!263_arg_1_7 is op created during fun def fmf") +(declare-fun count!263_arg_1_7 (I_count!263) Lst!2413) +(assert +(and +(not (forall ((h!413 Nat!2409) (BOUND_VARIABLE_663 I_plus!237) (BOUND_VARIABLE_671 I_count!263) (BOUND_VARIABLE_679 I_count!263) (BOUND_VARIABLE_687 I_count!263) (BOUND_VARIABLE_695 I_plus!237) (BOUND_VARIABLE_703 I_count!263) (BOUND_VARIABLE_711 I_count!263) (BOUND_VARIABLE_719 I_count!263)) (or (not (= (plus!237 (count!263 (count!263_arg_0_6 BOUND_VARIABLE_671) (cons!2414 h!413 nil!2417)) (count!263 (count!263_arg_0_6 BOUND_VARIABLE_671) (count!263_arg_1_7 BOUND_VARIABLE_679))) (count!263 (count!263_arg_0_6 BOUND_VARIABLE_671) (cons!2414 h!413 (count!263_arg_1_7 BOUND_VARIABLE_679))))) (= (plus!237 (count!263 (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)) (cons!2414 h!413 nil!2417)) (count!263 (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)) (count!263_arg_1_7 BOUND_VARIABLE_679))) (count!263 (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)) (cons!2414 h!413 (count!263_arg_1_7 BOUND_VARIABLE_679)))) (not (= (plus!237_arg_0_4 BOUND_VARIABLE_663) (count!263 (count!263_arg_0_6 BOUND_VARIABLE_671) (cons!2414 h!413 nil!2417)))) (not (= (plus!237_arg_1_5 BOUND_VARIABLE_663) (count!263 (count!263_arg_0_6 BOUND_VARIABLE_671) (count!263_arg_1_7 BOUND_VARIABLE_679)))) (not (= (count!263_arg_1_7 BOUND_VARIABLE_671) (cons!2414 h!413 nil!2417))) (not (= (count!263_arg_0_6 BOUND_VARIABLE_679) (count!263_arg_0_6 BOUND_VARIABLE_671))) (not (= (count!263_arg_0_6 BOUND_VARIABLE_687) (count!263_arg_0_6 BOUND_VARIABLE_671))) (not (= (count!263_arg_1_7 BOUND_VARIABLE_687) (cons!2414 h!413 (count!263_arg_1_7 BOUND_VARIABLE_679)))) (not (= (plus!237_arg_0_4 BOUND_VARIABLE_695) (count!263 (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)) (cons!2414 h!413 nil!2417)))) (not (= (plus!237_arg_1_5 BOUND_VARIABLE_695) (count!263 (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)) (count!263_arg_1_7 BOUND_VARIABLE_679)))) (not (= (count!263_arg_0_6 BOUND_VARIABLE_703) (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)))) (not (= (count!263_arg_1_7 BOUND_VARIABLE_703) (cons!2414 h!413 nil!2417))) (not (= (count!263_arg_0_6 BOUND_VARIABLE_711) (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)))) (not (= (count!263_arg_1_7 BOUND_VARIABLE_711) (count!263_arg_1_7 BOUND_VARIABLE_679))) (not (= (count!263_arg_0_6 BOUND_VARIABLE_719) (succ!2410 (count!263_arg_0_6 BOUND_VARIABLE_671)))) (not (= (count!263_arg_1_7 BOUND_VARIABLE_719) (cons!2414 h!413 (count!263_arg_1_7 BOUND_VARIABLE_679))))) )) +(forall ((?j I_plus!237)) (= (plus!237 (plus!237_arg_0_4 ?j) (plus!237_arg_1_5 ?j)) (ite (is-zero!2412 (plus!237_arg_0_4 ?j)) (plus!237_arg_1_5 ?j) (ite (is-succ!2410 (plus!237_arg_0_4 ?j)) (succ!2410 (plus!237 (ite (is-succ!2410 (plus!237_arg_0_4 ?j)) (pred!2411 (plus!237_arg_0_4 ?j)) (pred!2411_uf_1 (plus!237_arg_0_4 ?j))) (plus!237_arg_1_5 ?j))) error_value!2418))) ) +(forall ((?i I_plus!237)) (ite (is-zero!2412 (plus!237_arg_0_4 ?i)) true (ite (is-succ!2410 (plus!237_arg_0_4 ?i)) (not (forall ((?z I_plus!237)) (or (not (= (plus!237_arg_0_4 ?z) (ite (is-succ!2410 (plus!237_arg_0_4 ?i)) (pred!2411 (plus!237_arg_0_4 ?i)) (pred!2411_uf_1 (plus!237_arg_0_4 ?i))))) (not (= (plus!237_arg_1_5 ?z) (plus!237_arg_1_5 ?i)))) )) true)) ) +(forall ((?i I_count!263)) (= (count!263 (count!263_arg_0_6 ?i) (count!263_arg_1_7 ?i)) (ite (is-nil!2417 (count!263_arg_1_7 ?i)) zero!2412 (ite (is-cons!2414 (count!263_arg_1_7 ?i)) (ite (= (count!263_arg_0_6 ?i) (ite (is-cons!2414 (count!263_arg_1_7 ?i)) (head!2415 (count!263_arg_1_7 ?i)) (head!2415_uf_3 (count!263_arg_1_7 ?i)))) (succ!2410 (count!263 (count!263_arg_0_6 ?i) (ite (is-cons!2414 (count!263_arg_1_7 ?i)) (tail!2416 (count!263_arg_1_7 ?i)) (tail!2416_uf_2 (count!263_arg_1_7 ?i))))) (count!263 (count!263_arg_0_6 ?i) (ite (is-cons!2414 (count!263_arg_1_7 ?i)) (tail!2416 (count!263_arg_1_7 ?i)) (tail!2416_uf_2 (count!263_arg_1_7 ?i))))) error_value!2419))) ) +(forall ((?j I_count!263)) (ite (is-nil!2417 (count!263_arg_1_7 ?j)) true (ite (is-cons!2414 (count!263_arg_1_7 ?j)) (ite (= (count!263_arg_0_6 ?j) (ite (is-cons!2414 (count!263_arg_1_7 ?j)) (head!2415 (count!263_arg_1_7 ?j)) (head!2415_uf_3 (count!263_arg_1_7 ?j)))) (not (forall ((?z I_count!263)) (or (not (= (count!263_arg_0_6 ?z) (count!263_arg_0_6 ?j))) (not (= (count!263_arg_1_7 ?z) (ite (is-cons!2414 (count!263_arg_1_7 ?j)) (tail!2416 (count!263_arg_1_7 ?j)) (tail!2416_uf_2 (count!263_arg_1_7 ?j)))))) )) (not (forall ((?z I_count!263)) (or (not (= (count!263_arg_0_6 ?z) (count!263_arg_0_6 ?j))) (not (= (count!263_arg_1_7 ?z) (ite (is-cons!2414 (count!263_arg_1_7 ?j)) (tail!2416 (count!263_arg_1_7 ?j)) (tail!2416_uf_2 (count!263_arg_1_7 ?j)))))) ))) true)) ) +) +) +(check-sat) diff --git a/test/regress/regress1/gensys_brn001.smt2 b/test/regress/regress1/gensys_brn001.smt2 new file mode 100644 index 000000000..f3cc3c725 --- /dev/null +++ b/test/regress/regress1/gensys_brn001.smt2 @@ -0,0 +1,146 @@ +(set-logic QF_UF) +(set-info :source | +http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status sat) +(declare-sort U 0) +(declare-sort I 0) +(declare-fun unit () I) +(declare-fun op (I I) I) +(declare-fun e5 () I) +(declare-fun e4 () I) +(declare-fun e3 () I) +(declare-fun e2 () I) +(declare-fun e1 () I) +(declare-fun e0 () I) +(assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5))) (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5))) (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5))) (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5))) (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5))) (and (and (and (and (and (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5))) (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5))) (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5))) (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5))) (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5))) (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5))) (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5))) (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5))) (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5))) (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5))) (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5))) (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5))) (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5))) (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5))) (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5))) (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5))) (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5))) (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5))) (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5))) (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5))) (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)))))) +(assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_8 (op e1 e0)) (?v_21 (op e1 e1)) (?v_22 (op e1 e2)) (?v_23 (op e1 e3)) (?v_24 (op e1 e4)) (?v_25 (op e1 e5)) (?v_9 (op e2 e0)) (?v_28 (op e2 e1)) (?v_51 (op e2 e2)) (?v_52 (op e2 e3)) (?v_53 (op e2 e4)) (?v_54 (op e2 e5)) (?v_10 (op e3 e0)) (?v_29 (op e3 e1)) (?v_58 (op e3 e2)) (?v_91 (op e3 e3)) (?v_92 (op e3 e4)) (?v_93 (op e3 e5)) (?v_11 (op e4 e0)) (?v_30 (op e4 e1)) (?v_59 (op e4 e2)) (?v_98 (op e4 e3)) (?v_141 (op e4 e4)) (?v_142 (op e4 e5)) (?v_12 (op e5 e0)) (?v_31 (op e5 e1)) (?v_60 (op e5 e2)) (?v_99 (op e5 e3)) (?v_148 (op e5 e4)) (?v_201 (op e5 e5))) (let ((?v_0 (= ?v_1 e0)) (?v_7 (= ?v_1 e1)) (?v_13 (= ?v_1 e2)) (?v_14 (= ?v_1 e3)) (?v_15 (= ?v_1 e4)) (?v_16 (= ?v_1 e5)) (?v_18 (= ?v_2 e0)) (?v_26 (= ?v_2 e1)) (?v_33 (= ?v_2 e2)) (?v_36 (= ?v_2 e3)) (?v_39 (= ?v_2 e4)) (?v_42 (= ?v_2 e5)) (?v_46 (= ?v_3 e0)) (?v_55 (= ?v_3 e1)) (?v_63 (= ?v_3 e2)) (?v_68 (= ?v_3 e3)) (?v_73 (= ?v_3 e4)) (?v_78 (= ?v_3 e5)) (?v_84 (= ?v_4 e0)) (?v_94 (= ?v_4 e1)) (?v_103 (= ?v_4 e2)) (?v_110 (= ?v_4 e3)) (?v_117 (= ?v_4 e4)) (?v_124 (= ?v_4 e5)) (?v_132 (= ?v_5 e0)) (?v_143 (= ?v_5 e1)) (?v_153 (= ?v_5 e2)) (?v_162 (= ?v_5 e3)) (?v_171 (= ?v_5 e4)) (?v_180 (= ?v_5 e5)) (?v_190 (= ?v_6 e0)) (?v_202 (= ?v_6 e1)) (?v_213 (= ?v_6 e2)) (?v_224 (= ?v_6 e3)) (?v_235 (= ?v_6 e4)) (?v_246 (= ?v_6 e5)) (?v_17 (= ?v_8 e0)) (?v_20 (= ?v_8 e1)) (?v_32 (= ?v_8 e2)) (?v_35 (= ?v_8 e3)) (?v_38 (= ?v_8 e4)) (?v_41 (= ?v_8 e5)) (?v_19 (= ?v_21 e0)) (?v_27 (= ?v_21 e1)) (?v_34 (= ?v_21 e2)) (?v_37 (= ?v_21 e3)) (?v_40 (= ?v_21 e4)) (?v_43 (= ?v_21 e5)) (?v_47 (= ?v_22 e0)) (?v_56 (= ?v_22 e1)) (?v_64 (= ?v_22 e2)) (?v_69 (= ?v_22 e3)) (?v_74 (= ?v_22 e4)) (?v_79 (= ?v_22 e5)) (?v_85 (= ?v_23 e0)) (?v_95 (= ?v_23 e1)) (?v_104 (= ?v_23 e2)) (?v_111 (= ?v_23 e3)) (?v_118 (= ?v_23 e4)) (?v_125 (= ?v_23 e5)) (?v_133 (= ?v_24 e0)) (?v_144 (= ?v_24 e1)) (?v_154 (= ?v_24 e2)) (?v_163 (= ?v_24 e3)) (?v_172 (= ?v_24 e4)) (?v_181 (= ?v_24 e5)) (?v_191 (= ?v_25 e0)) (?v_203 (= ?v_25 e1)) (?v_214 (= ?v_25 e2)) (?v_225 (= ?v_25 e3)) (?v_236 (= ?v_25 e4)) (?v_247 (= ?v_25 e5)) (?v_44 (= ?v_9 e0)) (?v_49 (= ?v_9 e1)) (?v_61 (= ?v_9 e2)) (?v_66 (= ?v_9 e3)) (?v_71 (= ?v_9 e4)) (?v_76 (= ?v_9 e5)) (?v_45 (= ?v_28 e0)) (?v_50 (= ?v_28 e1)) (?v_62 (= ?v_28 e2)) (?v_67 (= ?v_28 e3)) (?v_72 (= ?v_28 e4)) (?v_77 (= ?v_28 e5)) (?v_48 (= ?v_51 e0)) (?v_57 (= ?v_51 e1)) (?v_65 (= ?v_51 e2)) (?v_70 (= ?v_51 e3)) (?v_75 (= ?v_51 e4)) (?v_80 (= ?v_51 e5)) (?v_86 (= ?v_52 e0)) (?v_96 (= ?v_52 e1)) (?v_105 (= ?v_52 e2)) (?v_112 (= ?v_52 e3)) (?v_119 (= ?v_52 e4)) (?v_126 (= ?v_52 e5)) (?v_134 (= ?v_53 e0)) (?v_145 (= ?v_53 e1)) (?v_155 (= ?v_53 e2)) (?v_164 (= ?v_53 e3)) (?v_173 (= ?v_53 e4)) (?v_182 (= ?v_53 e5)) (?v_192 (= ?v_54 e0)) (?v_204 (= ?v_54 e1)) (?v_215 (= ?v_54 e2)) (?v_226 (= ?v_54 e3)) (?v_237 (= ?v_54 e4)) (?v_248 (= ?v_54 e5)) (?v_81 (= ?v_10 e0)) (?v_88 (= ?v_10 e1)) (?v_100 (= ?v_10 e2)) (?v_107 (= ?v_10 e3)) (?v_114 (= ?v_10 e4)) (?v_121 (= ?v_10 e5)) (?v_82 (= ?v_29 e0)) (?v_89 (= ?v_29 e1)) (?v_101 (= ?v_29 e2)) (?v_108 (= ?v_29 e3)) (?v_115 (= ?v_29 e4)) (?v_122 (= ?v_29 e5)) (?v_83 (= ?v_58 e0)) (?v_90 (= ?v_58 e1)) (?v_102 (= ?v_58 e2)) (?v_109 (= ?v_58 e3)) (?v_116 (= ?v_58 e4)) (?v_123 (= ?v_58 e5)) (?v_87 (= ?v_91 e0)) (?v_97 (= ?v_91 e1)) (?v_106 (= ?v_91 e2)) (?v_113 (= ?v_91 e3)) (?v_120 (= ?v_91 e4)) (?v_127 (= ?v_91 e5)) (?v_135 (= ?v_92 e0)) (?v_146 (= ?v_92 e1)) (?v_156 (= ?v_92 e2)) (?v_165 (= ?v_92 e3)) (?v_174 (= ?v_92 e4)) (?v_183 (= ?v_92 e5)) (?v_193 (= ?v_93 e0)) (?v_205 (= ?v_93 e1)) (?v_216 (= ?v_93 e2)) (?v_227 (= ?v_93 e3)) (?v_238 (= ?v_93 e4)) (?v_249 (= ?v_93 e5)) (?v_128 (= ?v_11 e0)) (?v_137 (= ?v_11 e1)) (?v_149 (= ?v_11 e2)) (?v_158 (= ?v_11 e3)) (?v_167 (= ?v_11 e4)) (?v_176 (= ?v_11 e5)) (?v_129 (= ?v_30 e0)) (?v_138 (= ?v_30 e1)) (?v_150 (= ?v_30 e2)) (?v_159 (= ?v_30 e3)) (?v_168 (= ?v_30 e4)) (?v_177 (= ?v_30 e5)) (?v_130 (= ?v_59 e0)) (?v_139 (= ?v_59 e1)) (?v_151 (= ?v_59 e2)) (?v_160 (= ?v_59 e3)) (?v_169 (= ?v_59 e4)) (?v_178 (= ?v_59 e5)) (?v_131 (= ?v_98 e0)) (?v_140 (= ?v_98 e1)) (?v_152 (= ?v_98 e2)) (?v_161 (= ?v_98 e3)) (?v_170 (= ?v_98 e4)) (?v_179 (= ?v_98 e5)) (?v_136 (= ?v_141 e0)) (?v_147 (= ?v_141 e1)) (?v_157 (= ?v_141 e2)) (?v_166 (= ?v_141 e3)) (?v_175 (= ?v_141 e4)) (?v_184 (= ?v_141 e5)) (?v_194 (= ?v_142 e0)) (?v_206 (= ?v_142 e1)) (?v_217 (= ?v_142 e2)) (?v_228 (= ?v_142 e3)) (?v_239 (= ?v_142 e4)) (?v_250 (= ?v_142 e5)) (?v_185 (= ?v_12 e0)) (?v_196 (= ?v_12 e1)) (?v_208 (= ?v_12 e2)) (?v_219 (= ?v_12 e3)) (?v_230 (= ?v_12 e4)) (?v_241 (= ?v_12 e5)) (?v_186 (= ?v_31 e0)) (?v_197 (= ?v_31 e1)) (?v_209 (= ?v_31 e2)) (?v_220 (= ?v_31 e3)) (?v_231 (= ?v_31 e4)) (?v_242 (= ?v_31 e5)) (?v_187 (= ?v_60 e0)) (?v_198 (= ?v_60 e1)) (?v_210 (= ?v_60 e2)) (?v_221 (= ?v_60 e3)) (?v_232 (= ?v_60 e4)) (?v_243 (= ?v_60 e5)) (?v_188 (= ?v_99 e0)) (?v_199 (= ?v_99 e1)) (?v_211 (= ?v_99 e2)) (?v_222 (= ?v_99 e3)) (?v_233 (= ?v_99 e4)) (?v_244 (= ?v_99 e5)) (?v_189 (= ?v_148 e0)) (?v_200 (= ?v_148 e1)) (?v_212 (= ?v_148 e2)) (?v_223 (= ?v_148 e3)) (?v_234 (= ?v_148 e4)) (?v_245 (= ?v_148 e5)) (?v_195 (= ?v_201 e0)) (?v_207 (= ?v_201 e1)) (?v_218 (= ?v_201 e2)) (?v_229 (= ?v_201 e3)) (?v_240 (= ?v_201 e4)) (?v_251 (= ?v_201 e5))) (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or ?v_0 ?v_18) ?v_46) ?v_84) ?v_132) ?v_190) (or (or (or (or (or ?v_0 ?v_17) ?v_44) ?v_81) ?v_128) ?v_185)) (and (or (or (or (or (or ?v_7 ?v_26) ?v_55) ?v_94) ?v_143) ?v_202) (or (or (or (or (or ?v_7 ?v_20) ?v_49) ?v_88) ?v_137) ?v_196))) (and (or (or (or (or (or ?v_13 ?v_33) ?v_63) ?v_103) ?v_153) ?v_213) (or (or (or (or (or ?v_13 ?v_32) ?v_61) ?v_100) ?v_149) ?v_208))) (and (or (or (or (or (or ?v_14 ?v_36) ?v_68) ?v_110) ?v_162) ?v_224) (or (or (or (or (or ?v_14 ?v_35) ?v_66) ?v_107) ?v_158) ?v_219))) (and (or (or (or (or (or ?v_15 ?v_39) ?v_73) ?v_117) ?v_171) ?v_235) (or (or (or (or (or ?v_15 ?v_38) ?v_71) ?v_114) ?v_167) ?v_230))) (and (or (or (or (or (or ?v_16 ?v_42) ?v_78) ?v_124) ?v_180) ?v_246) (or (or (or (or (or ?v_16 ?v_41) ?v_76) ?v_121) ?v_176) ?v_241))) (and (and (and (and (and (and (or (or (or (or (or ?v_17 ?v_19) ?v_47) ?v_85) ?v_133) ?v_191) (or (or (or (or (or ?v_18 ?v_19) ?v_45) ?v_82) ?v_129) ?v_186)) (and (or (or (or (or (or ?v_20 ?v_27) ?v_56) ?v_95) ?v_144) ?v_203) (or (or (or (or (or ?v_26 ?v_27) ?v_50) ?v_89) ?v_138) ?v_197))) (and (or (or (or (or (or ?v_32 ?v_34) ?v_64) ?v_104) ?v_154) ?v_214) (or (or (or (or (or ?v_33 ?v_34) ?v_62) ?v_101) ?v_150) ?v_209))) (and (or (or (or (or (or ?v_35 ?v_37) ?v_69) ?v_111) ?v_163) ?v_225) (or (or (or (or (or ?v_36 ?v_37) ?v_67) ?v_108) ?v_159) ?v_220))) (and (or (or (or (or (or ?v_38 ?v_40) ?v_74) ?v_118) ?v_172) ?v_236) (or (or (or (or (or ?v_39 ?v_40) ?v_72) ?v_115) ?v_168) ?v_231))) (and (or (or (or (or (or ?v_41 ?v_43) ?v_79) ?v_125) ?v_181) ?v_247) (or (or (or (or (or ?v_42 ?v_43) ?v_77) ?v_122) ?v_177) ?v_242)))) (and (and (and (and (and (and (or (or (or (or (or ?v_44 ?v_45) ?v_48) ?v_86) ?v_134) ?v_192) (or (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_83) ?v_130) ?v_187)) (and (or (or (or (or (or ?v_49 ?v_50) ?v_57) ?v_96) ?v_145) ?v_204) (or (or (or (or (or ?v_55 ?v_56) ?v_57) ?v_90) ?v_139) ?v_198))) (and (or (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_105) ?v_155) ?v_215) (or (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_102) ?v_151) ?v_210))) (and (or (or (or (or (or ?v_66 ?v_67) ?v_70) ?v_112) ?v_164) ?v_226) (or (or (or (or (or ?v_68 ?v_69) ?v_70) ?v_109) ?v_160) ?v_221))) (and (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_119) ?v_173) ?v_237) (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_116) ?v_169) ?v_232))) (and (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_126) ?v_182) ?v_248) (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_123) ?v_178) ?v_243)))) (and (and (and (and (and (and (or (or (or (or (or ?v_81 ?v_82) ?v_83) ?v_87) ?v_135) ?v_193) (or (or (or (or (or ?v_84 ?v_85) ?v_86) ?v_87) ?v_131) ?v_188)) (and (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_97) ?v_146) ?v_205) (or (or (or (or (or ?v_94 ?v_95) ?v_96) ?v_97) ?v_140) ?v_199))) (and (or (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_106) ?v_156) ?v_216) (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_106) ?v_152) ?v_211))) (and (or (or (or (or (or ?v_107 ?v_108) ?v_109) ?v_113) ?v_165) ?v_227) (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_161) ?v_222))) (and (or (or (or (or (or ?v_114 ?v_115) ?v_116) ?v_120) ?v_174) ?v_238) (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_120) ?v_170) ?v_233))) (and (or (or (or (or (or ?v_121 ?v_122) ?v_123) ?v_127) ?v_183) ?v_249) (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_127) ?v_179) ?v_244)))) (and (and (and (and (and (and (or (or (or (or (or ?v_128 ?v_129) ?v_130) ?v_131) ?v_136) ?v_194) (or (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_136) ?v_189)) (and (or (or (or (or (or ?v_137 ?v_138) ?v_139) ?v_140) ?v_147) ?v_206) (or (or (or (or (or ?v_143 ?v_144) ?v_145) ?v_146) ?v_147) ?v_200))) (and (or (or (or (or (or ?v_149 ?v_150) ?v_151) ?v_152) ?v_157) ?v_217) (or (or (or (or (or ?v_153 ?v_154) ?v_155) ?v_156) ?v_157) ?v_212))) (and (or (or (or (or (or ?v_158 ?v_159) ?v_160) ?v_161) ?v_166) ?v_228) (or (or (or (or (or ?v_162 ?v_163) ?v_164) ?v_165) ?v_166) ?v_223))) (and (or (or (or (or (or ?v_167 ?v_168) ?v_169) ?v_170) ?v_175) ?v_239) (or (or (or (or (or ?v_171 ?v_172) ?v_173) ?v_174) ?v_175) ?v_234))) (and (or (or (or (or (or ?v_176 ?v_177) ?v_178) ?v_179) ?v_184) ?v_250) (or (or (or (or (or ?v_180 ?v_181) ?v_182) ?v_183) ?v_184) ?v_245)))) (and (and (and (and (and (and (or (or (or (or (or ?v_185 ?v_186) ?v_187) ?v_188) ?v_189) ?v_195) (or (or (or (or (or ?v_190 ?v_191) ?v_192) ?v_193) ?v_194) ?v_195)) (and (or (or (or (or (or ?v_196 ?v_197) ?v_198) ?v_199) ?v_200) ?v_207) (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_206) ?v_207))) (and (or (or (or (or (or ?v_208 ?v_209) ?v_210) ?v_211) ?v_212) ?v_218) (or (or (or (or (or ?v_213 ?v_214) ?v_215) ?v_216) ?v_217) ?v_218))) (and (or (or (or (or (or ?v_219 ?v_220) ?v_221) ?v_222) ?v_223) ?v_229) (or (or (or (or (or ?v_224 ?v_225) ?v_226) ?v_227) ?v_228) ?v_229))) (and (or (or (or (or (or ?v_230 ?v_231) ?v_232) ?v_233) ?v_234) ?v_240) (or (or (or (or (or ?v_235 ?v_236) ?v_237) ?v_238) ?v_239) ?v_240))) (and (or (or (or (or (or ?v_241 ?v_242) ?v_243) ?v_244) ?v_245) ?v_251) (or (or (or (or (or ?v_246 ?v_247) ?v_248) ?v_249) ?v_250) ?v_251))))))) +(assert (and (and (and (and (and (and (and (= (op unit e0) e0) (= (op e0 unit) e0)) (and (= (op unit e1) e1) (= (op e1 unit) e1))) (and (= (op unit e2) e2) (= (op e2 unit) e2))) (and (= (op unit e3) e3) (= (op e3 unit) e3))) (and (= (op unit e4) e4) (= (op e4 unit) e4))) (and (= (op unit e5) e5) (= (op e5 unit) e5))) (or (or (or (or (or (= unit e0) (= unit e1)) (= unit e2)) (= unit e3)) (= unit e4)) (= unit e5)))) +(assert (= unit e0)) +(assert (let ((?v_0 (op e0 e0)) (?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_7 (op e1 e1)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_14 (op e2 e2)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_21 (op e3 e3)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_28 (op e4 e4)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_4 ?v_5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_7)) (not (= ?v_6 ?v_8))) (not (= ?v_6 ?v_9))) (not (= ?v_6 ?v_10))) (not (= ?v_6 ?v_11))) (not (= ?v_7 ?v_8))) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_10 ?v_11)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_12 ?v_13)) (not (= ?v_12 ?v_14))) (not (= ?v_12 ?v_15))) (not (= ?v_12 ?v_16))) (not (= ?v_12 ?v_17))) (not (= ?v_13 ?v_14))) (not (= ?v_13 ?v_15))) (not (= ?v_13 ?v_16))) (not (= ?v_13 ?v_17))) (not (= ?v_14 ?v_15))) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_16 ?v_17)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_18 ?v_19)) (not (= ?v_18 ?v_20))) (not (= ?v_18 ?v_21))) (not (= ?v_18 ?v_22))) (not (= ?v_18 ?v_23))) (not (= ?v_19 ?v_20))) (not (= ?v_19 ?v_21))) (not (= ?v_19 ?v_22))) (not (= ?v_19 ?v_23))) (not (= ?v_20 ?v_21))) (not (= ?v_20 ?v_22))) (not (= ?v_20 ?v_23))) (not (= ?v_21 ?v_22))) (not (= ?v_21 ?v_23))) (not (= ?v_22 ?v_23)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_24 ?v_25)) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_24 ?v_28))) (not (= ?v_24 ?v_29))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_25 ?v_28))) (not (= ?v_25 ?v_29))) (not (= ?v_26 ?v_27))) (not (= ?v_26 ?v_28))) (not (= ?v_26 ?v_29))) (not (= ?v_27 ?v_28))) (not (= ?v_27 ?v_29))) (not (= ?v_28 ?v_29)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_30 ?v_31)) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_30 ?v_35))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_31 ?v_35))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_32 ?v_35))) (not (= ?v_33 ?v_34))) (not (= ?v_33 ?v_35))) (not (= ?v_34 ?v_35)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_6)) (not (= ?v_0 ?v_12))) (not (= ?v_0 ?v_18))) (not (= ?v_0 ?v_24))) (not (= ?v_0 ?v_30))) (not (= ?v_6 ?v_12))) (not (= ?v_6 ?v_18))) (not (= ?v_6 ?v_24))) (not (= ?v_6 ?v_30))) (not (= ?v_12 ?v_18))) (not (= ?v_12 ?v_24))) (not (= ?v_12 ?v_30))) (not (= ?v_18 ?v_24))) (not (= ?v_18 ?v_30))) (not (= ?v_24 ?v_30))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_7)) (not (= ?v_1 ?v_13))) (not (= ?v_1 ?v_19))) (not (= ?v_1 ?v_25))) (not (= ?v_1 ?v_31))) (not (= ?v_7 ?v_13))) (not (= ?v_7 ?v_19))) (not (= ?v_7 ?v_25))) (not (= ?v_7 ?v_31))) (not (= ?v_13 ?v_19))) (not (= ?v_13 ?v_25))) (not (= ?v_13 ?v_31))) (not (= ?v_19 ?v_25))) (not (= ?v_19 ?v_31))) (not (= ?v_25 ?v_31)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_8)) (not (= ?v_2 ?v_14))) (not (= ?v_2 ?v_20))) (not (= ?v_2 ?v_26))) (not (= ?v_2 ?v_32))) (not (= ?v_8 ?v_14))) (not (= ?v_8 ?v_20))) (not (= ?v_8 ?v_26))) (not (= ?v_8 ?v_32))) (not (= ?v_14 ?v_20))) (not (= ?v_14 ?v_26))) (not (= ?v_14 ?v_32))) (not (= ?v_20 ?v_26))) (not (= ?v_20 ?v_32))) (not (= ?v_26 ?v_32)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_9)) (not (= ?v_3 ?v_15))) (not (= ?v_3 ?v_21))) (not (= ?v_3 ?v_27))) (not (= ?v_3 ?v_33))) (not (= ?v_9 ?v_15))) (not (= ?v_9 ?v_21))) (not (= ?v_9 ?v_27))) (not (= ?v_9 ?v_33))) (not (= ?v_15 ?v_21))) (not (= ?v_15 ?v_27))) (not (= ?v_15 ?v_33))) (not (= ?v_21 ?v_27))) (not (= ?v_21 ?v_33))) (not (= ?v_27 ?v_33)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_10)) (not (= ?v_4 ?v_16))) (not (= ?v_4 ?v_22))) (not (= ?v_4 ?v_28))) (not (= ?v_4 ?v_34))) (not (= ?v_10 ?v_16))) (not (= ?v_10 ?v_22))) (not (= ?v_10 ?v_28))) (not (= ?v_10 ?v_34))) (not (= ?v_16 ?v_22))) (not (= ?v_16 ?v_28))) (not (= ?v_16 ?v_34))) (not (= ?v_22 ?v_28))) (not (= ?v_22 ?v_34))) (not (= ?v_28 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_11)) (not (= ?v_5 ?v_17))) (not (= ?v_5 ?v_23))) (not (= ?v_5 ?v_29))) (not (= ?v_5 ?v_35))) (not (= ?v_11 ?v_17))) (not (= ?v_11 ?v_23))) (not (= ?v_11 ?v_29))) (not (= ?v_11 ?v_35))) (not (= ?v_17 ?v_23))) (not (= ?v_17 ?v_29))) (not (= ?v_17 ?v_35))) (not (= ?v_23 ?v_29))) (not (= ?v_23 ?v_35))) (not (= ?v_29 ?v_35))))))) +(assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e3 e4))) (not (= e3 e5))) (not (= e4 e5)))) +(assert (not (and (and (and (and (= e0 (op e2 e3)) (= e2 (op e1 e1))) (= e3 (op e4 e4))) (= e4 (op e5 e2))) (= e5 (op e2 e1))))) +(assert (not (and (and (and (and (= e0 (op e2 e3)) (= e2 (op e1 e1))) (= e3 (op e5 e5))) (= e5 (op e4 e2))) (= e4 (op e2 e1))))) +(assert (not (and (and (and (and (= e0 (op e2 e4)) (= e2 (op e1 e1))) (= e4 (op e3 e3))) (= e3 (op e5 e2))) (= e5 (op e2 e1))))) +(assert (not (and (and (and (and (= e0 (op e2 e4)) (= e2 (op e1 e1))) (= e4 (op e5 e5))) (= e5 (op e3 e2))) (= e3 (op e2 e1))))) +(assert (not (and (and (and (and (= e0 (op e2 e5)) (= e2 (op e1 e1))) (= e5 (op e3 e3))) (= e3 (op e4 e2))) (= e4 (op e2 e1))))) +(assert (not (and (and (and (and (= e0 (op e2 e5)) (= e2 (op e1 e1))) (= e5 (op e4 e4))) (= e4 (op e3 e2))) (= e3 (op e2 e1))))) +(assert (not (and (and (and (and (= e0 (op e3 e2)) (= e3 (op e1 e1))) (= e2 (op e4 e4))) (= e4 (op e5 e3))) (= e5 (op e3 e1))))) +(assert (not (and (and (and (and (= e0 (op e3 e2)) (= e3 (op e1 e1))) (= e2 (op e5 e5))) (= e5 (op e4 e3))) (= e4 (op e3 e1))))) +(assert (not (and (and (and (and (= e0 (op e3 e4)) (= e3 (op e1 e1))) (= e4 (op e2 e2))) (= e2 (op e5 e3))) (= e5 (op e3 e1))))) +(assert (not (and (and (and (and (= e0 (op e3 e4)) (= e3 (op e1 e1))) (= e4 (op e5 e5))) (= e5 (op e2 e3))) (= e2 (op e3 e1))))) +(assert (not (and (and (and (and (= e0 (op e3 e5)) (= e3 (op e1 e1))) (= e5 (op e2 e2))) (= e2 (op e4 e3))) (= e4 (op e3 e1))))) +(assert (not (and (and (and (and (= e0 (op e3 e5)) (= e3 (op e1 e1))) (= e5 (op e4 e4))) (= e4 (op e2 e3))) (= e2 (op e3 e1))))) +(assert (not (and (and (and (and (= e0 (op e4 e2)) (= e4 (op e1 e1))) (= e2 (op e3 e3))) (= e3 (op e5 e4))) (= e5 (op e4 e1))))) +(assert (not (and (and (and (and (= e0 (op e4 e2)) (= e4 (op e1 e1))) (= e2 (op e5 e5))) (= e5 (op e3 e4))) (= e3 (op e4 e1))))) +(assert (not (and (and (and (and (= e0 (op e4 e3)) (= e4 (op e1 e1))) (= e3 (op e2 e2))) (= e2 (op e5 e4))) (= e5 (op e4 e1))))) +(assert (not (and (and (and (and (= e0 (op e4 e3)) (= e4 (op e1 e1))) (= e3 (op e5 e5))) (= e5 (op e2 e4))) (= e2 (op e4 e1))))) +(assert (not (and (and (and (and (= e0 (op e4 e5)) (= e4 (op e1 e1))) (= e5 (op e2 e2))) (= e2 (op e3 e4))) (= e3 (op e4 e1))))) +(assert (not (and (and (and (and (= e0 (op e4 e5)) (= e4 (op e1 e1))) (= e5 (op e3 e3))) (= e3 (op e2 e4))) (= e2 (op e4 e1))))) +(assert (not (and (and (and (and (= e0 (op e5 e2)) (= e5 (op e1 e1))) (= e2 (op e3 e3))) (= e3 (op e4 e5))) (= e4 (op e5 e1))))) +(assert (not (and (and (and (and (= e0 (op e5 e2)) (= e5 (op e1 e1))) (= e2 (op e4 e4))) (= e4 (op e3 e5))) (= e3 (op e5 e1))))) +(assert (not (and (and (and (and (= e0 (op e5 e3)) (= e5 (op e1 e1))) (= e3 (op e2 e2))) (= e2 (op e4 e5))) (= e4 (op e5 e1))))) +(assert (not (and (and (and (and (= e0 (op e5 e3)) (= e5 (op e1 e1))) (= e3 (op e4 e4))) (= e4 (op e2 e5))) (= e2 (op e5 e1))))) +(assert (not (and (and (and (and (= e0 (op e5 e4)) (= e5 (op e1 e1))) (= e4 (op e2 e2))) (= e2 (op e3 e5))) (= e3 (op e5 e1))))) +(assert (not (and (and (and (and (= e0 (op e5 e4)) (= e5 (op e1 e1))) (= e4 (op e3 e3))) (= e3 (op e2 e5))) (= e2 (op e5 e1))))) +(assert (not (and (and (and (and (= e0 (op e1 e3)) (= e1 (op e2 e2))) (= e3 (op e4 e4))) (= e4 (op e5 e1))) (= e5 (op e1 e2))))) +(assert (not (and (and (and (and (= e0 (op e1 e3)) (= e1 (op e2 e2))) (= e3 (op e5 e5))) (= e5 (op e4 e1))) (= e4 (op e1 e2))))) +(assert (not (and (and (and (and (= e0 (op e1 e4)) (= e1 (op e2 e2))) (= e4 (op e3 e3))) (= e3 (op e5 e1))) (= e5 (op e1 e2))))) +(assert (not (and (and (and (and (= e0 (op e1 e4)) (= e1 (op e2 e2))) (= e4 (op e5 e5))) (= e5 (op e3 e1))) (= e3 (op e1 e2))))) +(assert (not (and (and (and (and (= e0 (op e1 e5)) (= e1 (op e2 e2))) (= e5 (op e3 e3))) (= e3 (op e4 e1))) (= e4 (op e1 e2))))) +(assert (not (and (and (and (and (= e0 (op e1 e5)) (= e1 (op e2 e2))) (= e5 (op e4 e4))) (= e4 (op e3 e1))) (= e3 (op e1 e2))))) +(assert (not (and (and (and (and (= e0 (op e3 e1)) (= e3 (op e2 e2))) (= e1 (op e4 e4))) (= e4 (op e5 e3))) (= e5 (op e3 e2))))) +(assert (not (and (and (and (and (= e0 (op e3 e1)) (= e3 (op e2 e2))) (= e1 (op e5 e5))) (= e5 (op e4 e3))) (= e4 (op e3 e2))))) +(assert (not (and (and (and (and (= e0 (op e3 e4)) (= e3 (op e2 e2))) (= e4 (op e1 e1))) (= e1 (op e5 e3))) (= e5 (op e3 e2))))) +(assert (not (and (and (and (and (= e0 (op e3 e4)) (= e3 (op e2 e2))) (= e4 (op e5 e5))) (= e5 (op e1 e3))) (= e1 (op e3 e2))))) +(assert (not (and (and (and (and (= e0 (op e3 e5)) (= e3 (op e2 e2))) (= e5 (op e1 e1))) (= e1 (op e4 e3))) (= e4 (op e3 e2))))) +(assert (not (and (and (and (and (= e0 (op e3 e5)) (= e3 (op e2 e2))) (= e5 (op e4 e4))) (= e4 (op e1 e3))) (= e1 (op e3 e2))))) +(assert (not (and (and (and (and (= e0 (op e4 e1)) (= e4 (op e2 e2))) (= e1 (op e3 e3))) (= e3 (op e5 e4))) (= e5 (op e4 e2))))) +(assert (not (and (and (and (and (= e0 (op e4 e1)) (= e4 (op e2 e2))) (= e1 (op e5 e5))) (= e5 (op e3 e4))) (= e3 (op e4 e2))))) +(assert (not (and (and (and (and (= e0 (op e4 e3)) (= e4 (op e2 e2))) (= e3 (op e1 e1))) (= e1 (op e5 e4))) (= e5 (op e4 e2))))) +(assert (not (and (and (and (and (= e0 (op e4 e3)) (= e4 (op e2 e2))) (= e3 (op e5 e5))) (= e5 (op e1 e4))) (= e1 (op e4 e2))))) +(assert (not (and (and (and (and (= e0 (op e4 e5)) (= e4 (op e2 e2))) (= e5 (op e1 e1))) (= e1 (op e3 e4))) (= e3 (op e4 e2))))) +(assert (not (and (and (and (and (= e0 (op e4 e5)) (= e4 (op e2 e2))) (= e5 (op e3 e3))) (= e3 (op e1 e4))) (= e1 (op e4 e2))))) +(assert (not (and (and (and (and (= e0 (op e5 e1)) (= e5 (op e2 e2))) (= e1 (op e3 e3))) (= e3 (op e4 e5))) (= e4 (op e5 e2))))) +(assert (not (and (and (and (and (= e0 (op e5 e1)) (= e5 (op e2 e2))) (= e1 (op e4 e4))) (= e4 (op e3 e5))) (= e3 (op e5 e2))))) +(assert (not (and (and (and (and (= e0 (op e5 e3)) (= e5 (op e2 e2))) (= e3 (op e1 e1))) (= e1 (op e4 e5))) (= e4 (op e5 e2))))) +(assert (not (and (and (and (and (= e0 (op e5 e3)) (= e5 (op e2 e2))) (= e3 (op e4 e4))) (= e4 (op e1 e5))) (= e1 (op e5 e2))))) +(assert (not (and (and (and (and (= e0 (op e5 e4)) (= e5 (op e2 e2))) (= e4 (op e1 e1))) (= e1 (op e3 e5))) (= e3 (op e5 e2))))) +(assert (not (and (and (and (and (= e0 (op e5 e4)) (= e5 (op e2 e2))) (= e4 (op e3 e3))) (= e3 (op e1 e5))) (= e1 (op e5 e2))))) +(assert (not (and (and (and (and (= e0 (op e1 e2)) (= e1 (op e3 e3))) (= e2 (op e4 e4))) (= e4 (op e5 e1))) (= e5 (op e1 e3))))) +(assert (not (and (and (and (and (= e0 (op e1 e2)) (= e1 (op e3 e3))) (= e2 (op e5 e5))) (= e5 (op e4 e1))) (= e4 (op e1 e3))))) +(assert (not (and (and (and (and (= e0 (op e1 e4)) (= e1 (op e3 e3))) (= e4 (op e2 e2))) (= e2 (op e5 e1))) (= e5 (op e1 e3))))) +(assert (not (and (and (and (and (= e0 (op e1 e4)) (= e1 (op e3 e3))) (= e4 (op e5 e5))) (= e5 (op e2 e1))) (= e2 (op e1 e3))))) +(assert (not (and (and (and (and (= e0 (op e1 e5)) (= e1 (op e3 e3))) (= e5 (op e2 e2))) (= e2 (op e4 e1))) (= e4 (op e1 e3))))) +(assert (not (and (and (and (and (= e0 (op e1 e5)) (= e1 (op e3 e3))) (= e5 (op e4 e4))) (= e4 (op e2 e1))) (= e2 (op e1 e3))))) +(assert (not (and (and (and (and (= e0 (op e2 e1)) (= e2 (op e3 e3))) (= e1 (op e4 e4))) (= e4 (op e5 e2))) (= e5 (op e2 e3))))) +(assert (not (and (and (and (and (= e0 (op e2 e1)) (= e2 (op e3 e3))) (= e1 (op e5 e5))) (= e5 (op e4 e2))) (= e4 (op e2 e3))))) +(assert (not (and (and (and (and (= e0 (op e2 e4)) (= e2 (op e3 e3))) (= e4 (op e1 e1))) (= e1 (op e5 e2))) (= e5 (op e2 e3))))) +(assert (not (and (and (and (and (= e0 (op e2 e4)) (= e2 (op e3 e3))) (= e4 (op e5 e5))) (= e5 (op e1 e2))) (= e1 (op e2 e3))))) +(assert (not (and (and (and (and (= e0 (op e2 e5)) (= e2 (op e3 e3))) (= e5 (op e1 e1))) (= e1 (op e4 e2))) (= e4 (op e2 e3))))) +(assert (not (and (and (and (and (= e0 (op e2 e5)) (= e2 (op e3 e3))) (= e5 (op e4 e4))) (= e4 (op e1 e2))) (= e1 (op e2 e3))))) +(assert (not (and (and (and (and (= e0 (op e4 e1)) (= e4 (op e3 e3))) (= e1 (op e2 e2))) (= e2 (op e5 e4))) (= e5 (op e4 e3))))) +(assert (not (and (and (and (and (= e0 (op e4 e1)) (= e4 (op e3 e3))) (= e1 (op e5 e5))) (= e5 (op e2 e4))) (= e2 (op e4 e3))))) +(assert (not (and (and (and (and (= e0 (op e4 e2)) (= e4 (op e3 e3))) (= e2 (op e1 e1))) (= e1 (op e5 e4))) (= e5 (op e4 e3))))) +(assert (not (and (and (and (and (= e0 (op e4 e2)) (= e4 (op e3 e3))) (= e2 (op e5 e5))) (= e5 (op e1 e4))) (= e1 (op e4 e3))))) +(assert (not (and (and (and (and (= e0 (op e4 e5)) (= e4 (op e3 e3))) (= e5 (op e1 e1))) (= e1 (op e2 e4))) (= e2 (op e4 e3))))) +(assert (not (and (and (and (and (= e0 (op e4 e5)) (= e4 (op e3 e3))) (= e5 (op e2 e2))) (= e2 (op e1 e4))) (= e1 (op e4 e3))))) +(assert (not (and (and (and (and (= e0 (op e5 e1)) (= e5 (op e3 e3))) (= e1 (op e2 e2))) (= e2 (op e4 e5))) (= e4 (op e5 e3))))) +(assert (not (and (and (and (and (= e0 (op e5 e1)) (= e5 (op e3 e3))) (= e1 (op e4 e4))) (= e4 (op e2 e5))) (= e2 (op e5 e3))))) +(assert (not (and (and (and (and (= e0 (op e5 e2)) (= e5 (op e3 e3))) (= e2 (op e1 e1))) (= e1 (op e4 e5))) (= e4 (op e5 e3))))) +(assert (not (and (and (and (and (= e0 (op e5 e2)) (= e5 (op e3 e3))) (= e2 (op e4 e4))) (= e4 (op e1 e5))) (= e1 (op e5 e3))))) +(assert (not (and (and (and (and (= e0 (op e5 e4)) (= e5 (op e3 e3))) (= e4 (op e1 e1))) (= e1 (op e2 e5))) (= e2 (op e5 e3))))) +(assert (not (and (and (and (and (= e0 (op e5 e4)) (= e5 (op e3 e3))) (= e4 (op e2 e2))) (= e2 (op e1 e5))) (= e1 (op e5 e3))))) +(assert (not (and (and (and (and (= e0 (op e1 e2)) (= e1 (op e4 e4))) (= e2 (op e3 e3))) (= e3 (op e5 e1))) (= e5 (op e1 e4))))) +(assert (not (and (and (and (and (= e0 (op e1 e2)) (= e1 (op e4 e4))) (= e2 (op e5 e5))) (= e5 (op e3 e1))) (= e3 (op e1 e4))))) +(assert (not (and (and (and (and (= e0 (op e1 e3)) (= e1 (op e4 e4))) (= e3 (op e2 e2))) (= e2 (op e5 e1))) (= e5 (op e1 e4))))) +(assert (not (and (and (and (and (= e0 (op e1 e3)) (= e1 (op e4 e4))) (= e3 (op e5 e5))) (= e5 (op e2 e1))) (= e2 (op e1 e4))))) +(assert (not (and (and (and (and (= e0 (op e1 e5)) (= e1 (op e4 e4))) (= e5 (op e2 e2))) (= e2 (op e3 e1))) (= e3 (op e1 e4))))) +(assert (not (and (and (and (and (= e0 (op e1 e5)) (= e1 (op e4 e4))) (= e5 (op e3 e3))) (= e3 (op e2 e1))) (= e2 (op e1 e4))))) +(assert (not (and (and (and (and (= e0 (op e2 e1)) (= e2 (op e4 e4))) (= e1 (op e3 e3))) (= e3 (op e5 e2))) (= e5 (op e2 e4))))) +(assert (not (and (and (and (and (= e0 (op e2 e1)) (= e2 (op e4 e4))) (= e1 (op e5 e5))) (= e5 (op e3 e2))) (= e3 (op e2 e4))))) +(assert (not (and (and (and (and (= e0 (op e2 e3)) (= e2 (op e4 e4))) (= e3 (op e1 e1))) (= e1 (op e5 e2))) (= e5 (op e2 e4))))) +(assert (not (and (and (and (and (= e0 (op e2 e3)) (= e2 (op e4 e4))) (= e3 (op e5 e5))) (= e5 (op e1 e2))) (= e1 (op e2 e4))))) +(assert (not (and (and (and (and (= e0 (op e2 e5)) (= e2 (op e4 e4))) (= e5 (op e1 e1))) (= e1 (op e3 e2))) (= e3 (op e2 e4))))) +(assert (not (and (and (and (and (= e0 (op e2 e5)) (= e2 (op e4 e4))) (= e5 (op e3 e3))) (= e3 (op e1 e2))) (= e1 (op e2 e4))))) +(assert (not (and (and (and (and (= e0 (op e3 e1)) (= e3 (op e4 e4))) (= e1 (op e2 e2))) (= e2 (op e5 e3))) (= e5 (op e3 e4))))) +(assert (not (and (and (and (and (= e0 (op e3 e1)) (= e3 (op e4 e4))) (= e1 (op e5 e5))) (= e5 (op e2 e3))) (= e2 (op e3 e4))))) +(assert (not (and (and (and (and (= e0 (op e3 e2)) (= e3 (op e4 e4))) (= e2 (op e1 e1))) (= e1 (op e5 e3))) (= e5 (op e3 e4))))) +(assert (not (and (and (and (and (= e0 (op e3 e2)) (= e3 (op e4 e4))) (= e2 (op e5 e5))) (= e5 (op e1 e3))) (= e1 (op e3 e4))))) +(assert (not (and (and (and (and (= e0 (op e3 e5)) (= e3 (op e4 e4))) (= e5 (op e1 e1))) (= e1 (op e2 e3))) (= e2 (op e3 e4))))) +(assert (not (and (and (and (and (= e0 (op e3 e5)) (= e3 (op e4 e4))) (= e5 (op e2 e2))) (= e2 (op e1 e3))) (= e1 (op e3 e4))))) +(assert (not (and (and (and (and (= e0 (op e5 e1)) (= e5 (op e4 e4))) (= e1 (op e2 e2))) (= e2 (op e3 e5))) (= e3 (op e5 e4))))) +(assert (not (and (and (and (and (= e0 (op e5 e1)) (= e5 (op e4 e4))) (= e1 (op e3 e3))) (= e3 (op e2 e5))) (= e2 (op e5 e4))))) +(assert (not (and (and (and (and (= e0 (op e5 e2)) (= e5 (op e4 e4))) (= e2 (op e1 e1))) (= e1 (op e3 e5))) (= e3 (op e5 e4))))) +(assert (not (and (and (and (and (= e0 (op e5 e2)) (= e5 (op e4 e4))) (= e2 (op e3 e3))) (= e3 (op e1 e5))) (= e1 (op e5 e4))))) +(assert (not (and (and (and (and (= e0 (op e5 e3)) (= e5 (op e4 e4))) (= e3 (op e1 e1))) (= e1 (op e2 e5))) (= e2 (op e5 e4))))) +(assert (not (and (and (and (and (= e0 (op e5 e3)) (= e5 (op e4 e4))) (= e3 (op e2 e2))) (= e2 (op e1 e5))) (= e1 (op e5 e4))))) +(assert (not (and (and (and (and (= e0 (op e1 e2)) (= e1 (op e5 e5))) (= e2 (op e3 e3))) (= e3 (op e4 e1))) (= e4 (op e1 e5))))) +(assert (not (and (and (and (and (= e0 (op e1 e2)) (= e1 (op e5 e5))) (= e2 (op e4 e4))) (= e4 (op e3 e1))) (= e3 (op e1 e5))))) +(assert (not (and (and (and (and (= e0 (op e1 e3)) (= e1 (op e5 e5))) (= e3 (op e2 e2))) (= e2 (op e4 e1))) (= e4 (op e1 e5))))) +(assert (not (and (and (and (and (= e0 (op e1 e3)) (= e1 (op e5 e5))) (= e3 (op e4 e4))) (= e4 (op e2 e1))) (= e2 (op e1 e5))))) +(assert (not (and (and (and (and (= e0 (op e1 e4)) (= e1 (op e5 e5))) (= e4 (op e2 e2))) (= e2 (op e3 e1))) (= e3 (op e1 e5))))) +(assert (not (and (and (and (and (= e0 (op e1 e4)) (= e1 (op e5 e5))) (= e4 (op e3 e3))) (= e3 (op e2 e1))) (= e2 (op e1 e5))))) +(assert (not (and (and (and (and (= e0 (op e2 e1)) (= e2 (op e5 e5))) (= e1 (op e3 e3))) (= e3 (op e4 e2))) (= e4 (op e2 e5))))) +(assert (not (and (and (and (and (= e0 (op e2 e1)) (= e2 (op e5 e5))) (= e1 (op e4 e4))) (= e4 (op e3 e2))) (= e3 (op e2 e5))))) +(assert (not (and (and (and (and (= e0 (op e2 e3)) (= e2 (op e5 e5))) (= e3 (op e1 e1))) (= e1 (op e4 e2))) (= e4 (op e2 e5))))) +(assert (not (and (and (and (and (= e0 (op e2 e3)) (= e2 (op e5 e5))) (= e3 (op e4 e4))) (= e4 (op e1 e2))) (= e1 (op e2 e5))))) +(assert (not (and (and (and (and (= e0 (op e2 e4)) (= e2 (op e5 e5))) (= e4 (op e1 e1))) (= e1 (op e3 e2))) (= e3 (op e2 e5))))) +(assert (not (and (and (and (and (= e0 (op e2 e4)) (= e2 (op e5 e5))) (= e4 (op e3 e3))) (= e3 (op e1 e2))) (= e1 (op e2 e5))))) +(assert (not (and (and (and (and (= e0 (op e3 e1)) (= e3 (op e5 e5))) (= e1 (op e2 e2))) (= e2 (op e4 e3))) (= e4 (op e3 e5))))) +(assert (not (and (and (and (and (= e0 (op e3 e1)) (= e3 (op e5 e5))) (= e1 (op e4 e4))) (= e4 (op e2 e3))) (= e2 (op e3 e5))))) +(assert (not (and (and (and (and (= e0 (op e3 e2)) (= e3 (op e5 e5))) (= e2 (op e1 e1))) (= e1 (op e4 e3))) (= e4 (op e3 e5))))) +(assert (not (and (and (and (and (= e0 (op e3 e2)) (= e3 (op e5 e5))) (= e2 (op e4 e4))) (= e4 (op e1 e3))) (= e1 (op e3 e5))))) +(assert (not (and (and (and (and (= e0 (op e3 e4)) (= e3 (op e5 e5))) (= e4 (op e1 e1))) (= e1 (op e2 e3))) (= e2 (op e3 e5))))) +(assert (not (and (and (and (and (= e0 (op e3 e4)) (= e3 (op e5 e5))) (= e4 (op e2 e2))) (= e2 (op e1 e3))) (= e1 (op e3 e5))))) +(assert (not (and (and (and (and (= e0 (op e4 e1)) (= e4 (op e5 e5))) (= e1 (op e2 e2))) (= e2 (op e3 e4))) (= e3 (op e4 e5))))) +(assert (not (and (and (and (and (= e0 (op e4 e1)) (= e4 (op e5 e5))) (= e1 (op e3 e3))) (= e3 (op e2 e4))) (= e2 (op e4 e5))))) +(assert (not (and (and (and (and (= e0 (op e4 e2)) (= e4 (op e5 e5))) (= e2 (op e1 e1))) (= e1 (op e3 e4))) (= e3 (op e4 e5))))) +(assert (not (and (and (and (and (= e0 (op e4 e2)) (= e4 (op e5 e5))) (= e2 (op e3 e3))) (= e3 (op e1 e4))) (= e1 (op e4 e5))))) +(assert (not (and (and (and (and (= e0 (op e4 e3)) (= e4 (op e5 e5))) (= e3 (op e1 e1))) (= e1 (op e2 e4))) (= e2 (op e4 e5))))) +(assert (not (and (and (and (and (= e0 (op e4 e3)) (= e4 (op e5 e5))) (= e3 (op e2 e2))) (= e2 (op e1 e4))) (= e1 (op e4 e5))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/ho/Makefile.am b/test/regress/regress1/ho/Makefile.am new file mode 100644 index 000000000..6ae3a116f --- /dev/null +++ b/test/regress/regress1/ho/Makefile.am @@ -0,0 +1,35 @@ +# don't override a BINARY imported from a personal.mk +@mk_if@eq ($(BINARY),) +@mk_empty@BINARY = cvc4 +end@mk_if@ + +LOG_COMPILER = @srcdir@/../../run_regression +AM_LOG_FLAGS = $(RUN_REGRESSION_ARGS) @abs_top_builddir@/src/main/$(BINARY)$(EXEEXT) + +if AUTOMAKE_1_11 +# old-style (pre-automake 1.12) test harness +TESTS_ENVIRONMENT = \ + $(LOG_COMPILER) \ + $(AM_LOG_FLAGS) $(LOG_FLAGS) +endif + +# These are run for all build profiles. +# If a test shouldn't be run in e.g. competition mode, +# put it below in "TESTS +=" +TESTS = \ + auth0068.smt2 \ + fta0409.smt2 \ + ho-exponential-model.smt2 \ + ho-matching-enum-2.smt2 \ + ho-std-fmf.smt2 + +EXTRA_DIST = $(TESTS) \ + hoa0102.smt2 + +# synonyms for "check" in this directory +.PHONY: regress regress1 test +regress regress1 test: check + +# do nothing in this subdir +.PHONY: regress0 regress2 regress3 regress4 +regress0 regress2 regress3 regress4: diff --git a/test/regress/regress1/ho/auth0068.smt2 b/test/regress/regress1/ho/auth0068.smt2 new file mode 100644 index 000000000..eb0bb5d36 --- /dev/null +++ b/test/regress/regress1/ho/auth0068.smt2 @@ -0,0 +1,491 @@ +; COMMAND-LINE: --uf-ho +; EXPECT: unsat +(set-logic ALL) +(set-info :status unsat) +(declare-sort Msg$ 0) +(declare-sort Nat$ 0) +(declare-sort Agent$ 0) +(declare-sort Event$ 0) +(declare-sort Msg_set$ 0) +(declare-sort Msg_list$ 0) +(declare-sort Agent_set$ 0) +(declare-sort Event_set$ 0) +(declare-sort Agent_list$ 0) +(declare-sort Event_list$ 0) +(declare-sort Event_option$ 0) +(declare-sort Msg_list_set$ 0) +(declare-sort Agent_list_set$ 0) +(declare-sort Event_list_set$ 0) +(declare-sort Event_list_list$ 0) +(declare-fun p$ () (-> Event$ Bool)) +(declare-fun uu$ ((-> Msg$ Bool) (-> Msg$ Bool) Msg$) Bool) +(declare-fun bad$ () Agent_set$) +(declare-fun nil$ () Event_list$) +(declare-fun set$ (Event_list$) Event_set$) +(declare-fun spy$ () Agent$) +(declare-fun uua$ (Event_set$ (-> Event$ Bool) Event$) Bool) +(declare-fun uub$ (Agent_set$ (-> Agent$ Bool) Agent$) Bool) +(declare-fun uuc$ (Msg_set$ (-> Msg$ Bool) Msg$) Bool) +(declare-fun uud$ (Event_set$ Event$) Bool) +(declare-fun uue$ (Agent_set$ Agent$) Bool) +(declare-fun uuf$ (Msg_set$ Msg$) Bool) +(declare-fun uug$ (Event$ Event_list$) Bool) +(declare-fun uuh$ (Event$ Event_list$) Bool) +(declare-fun uui$ ((-> Event$ Bool) Event$ Event$) Bool) +(declare-fun uuj$ (Event_list_set$ Event_list$ Event$) Bool) +(declare-fun uuk$ (Msg$ (-> Msg$ Bool) Msg$) Bool) +(declare-fun uul$ (Msg$ Msg_set$ Msg$) Bool) +(declare-fun uum$ (Event$ Event_set$ Event$) Bool) +(declare-fun uun$ (Agent$ Agent_set$ Agent$) Bool) +(declare-fun uuo$ (Event_list$ Agent$ Agent$ Msg$) Msg_set$) +(declare-fun uup$ (Event_list$ Agent$ Msg$) Msg_set$) +(declare-fun uuq$ (Event_list$ Agent$ Msg$) Msg_set$) +(declare-fun uur$ (Agent$ Event_list$ Agent$ Agent$ Msg$) Msg_set$) +(declare-fun uus$ (Agent$ Event_list$ Agent$ Msg$) Msg_set$) +(declare-fun bind$ (Event_list$ (-> Event$ Event_list$)) Event_list$) +(declare-fun cons$ (Event$ Event_list$) Event_list$) +(declare-fun gets$ (Agent$ Msg$) Event$) +(declare-fun maps$ ((-> Event$ Event_list$)) (-> Event_list$ Event_list$)) +(declare-fun nil$a () Event_list_list$) +(declare-fun nil$b () Msg_list$) +(declare-fun nil$c () Agent_list$) +(declare-fun null$ (Event_list$) Bool) +(declare-fun says$ (Agent$ Agent$ Msg$) Event$) +(declare-fun set$a (Msg_list$) Msg_set$) +(declare-fun set$b (Agent_list$) Agent_set$) +(declare-fun succ$ (Event_list_set$ Event_list$) Event_set$) +(declare-fun cons$a (Event_list$ Event_list_list$) Event_list_list$) +(declare-fun cons$b (Msg$ Msg_list$) Msg_list$) +(declare-fun cons$c (Agent$ Agent_list$) Agent_list$) +(declare-fun knows$ (Agent$ Event_list$) Msg_set$) +(declare-fun notes$ (Agent$ Msg$) Event$) +(declare-fun succ$a (Msg_list_set$ Msg_list$) Msg_set$) +(declare-fun succ$b (Agent_list_set$ Agent_list$) Agent_set$) +(declare-fun append$ (Event_list$ Event_list$) Event_list$) +(declare-fun insert$ (Msg$ Msg_set$) Msg_set$) +(declare-fun member$ (Agent$ Agent_set$) Bool) +(declare-fun splice$ (Event_list$) (-> Event_list$ Event_list$)) +(declare-fun append$a (Msg_list$ Msg_list$) Msg_list$) +(declare-fun append$b (Agent_list$ Agent_list$) Agent_list$) +(declare-fun collect$ ((-> Msg$ Bool)) Msg_set$) +(declare-fun insert$a (Event$) (-> Event_list$ Event_list$)) +(declare-fun insert$b (Event$ Event_set$) Event_set$) +(declare-fun insert$c (Agent$ Agent_set$) Agent_set$) +(declare-fun insert$d (Msg$ Msg_list$) Msg_list$) +(declare-fun insert$e (Agent$ Agent_list$) Agent_list$) +(declare-fun less_eq$ (Msg_set$ Msg_set$) Bool) +(declare-fun list_ex$ ((-> Event$ Bool)) (-> Event_list$ Bool)) +(declare-fun member$a (Msg$ Msg_set$) Bool) +(declare-fun member$b (Event$ Event_set$) Bool) +(declare-fun member$c (Event_list$ Event_list_set$) Bool) +(declare-fun member$d (Event_list$ Event$) Bool) +(declare-fun member$e (Msg_list$ Msg_list_set$) Bool) +(declare-fun member$f (Agent_list$ Agent_list_set$) Bool) +(declare-fun member$g (Msg_list$ Msg$) Bool) +(declare-fun member$h (Agent_list$ Agent$) Bool) +(declare-fun rotate1$ (Event_list$) Event_list$) +(declare-fun subseqs$ (Event_list$) Event_list_list$) +(declare-fun antimono$ ((-> Msg_set$ Msg_set$)) Bool) +(declare-fun collect$a ((-> Event$ Bool)) Event_set$) +(declare-fun collect$b ((-> Agent$ Bool)) Agent_set$) +(declare-fun greatest$ ((-> Msg_set$ Bool)) Msg_set$) +(declare-fun less_eq$a (Event_set$ Event_set$) Bool) +(declare-fun less_eq$b (Agent_set$ Agent_set$) Bool) +(declare-fun less_eq$c ((-> Event$ Bool) (-> Event$ Bool)) Bool) +(declare-fun less_eq$d ((-> Agent$ Bool) (-> Agent$ Bool)) Bool) +(declare-fun less_eq$e ((-> Msg$ Bool) (-> Msg$ Bool)) Bool) +(declare-fun less_eq$f ((-> Bool Msg_set$) (-> Bool Msg_set$)) Bool) +(declare-fun list_all$ ((-> Event$ Bool) Event_list$) Bool) +(declare-fun list_ex$a ((-> Msg$ Bool) Msg_list$) Bool) +(declare-fun list_ex$b ((-> Agent$ Bool) Agent_list$) Bool) +(declare-fun list_ex1$ ((-> Event$ Bool)) (-> Event_list$ Bool)) +(declare-fun case_list$ (Bool (-> Event$ (-> Event_list$ Bool)) Event_list$) Bool) +(declare-fun initState$ (Agent$) Msg_set$) +(declare-fun list_all$a ((-> Msg$ Bool) Msg_list$) Bool) +(declare-fun list_all$b ((-> Agent$ Bool) Agent_list$) Bool) +(declare-fun list_ex1$a ((-> Msg$ Bool) Msg_list$) Bool) +(declare-fun list_ex1$b ((-> Agent$ Bool) Agent_list$) Bool) +(declare-fun takeWhile$ ((-> Event$ Bool) Event_list$) Event_list$) +(declare-fun case_event$ ((-> Agent$ (-> Agent$ (-> Msg$ Msg_set$))) (-> Agent$ (-> Msg$ Msg_set$)) (-> Agent$ (-> Msg$ Msg_set$)) Event$) Msg_set$) +(declare-fun gen_length$ (Nat$) (-> Event_list$ Nat$)) +(declare-fun map_filter$ ((-> Event$ Event_option$)) (-> Event_list$ Event_list$)) +(declare-fun takeWhile$a ((-> Msg$ Bool) Msg_list$) Msg_list$) +(declare-fun takeWhile$b ((-> Agent$ Bool) Agent_list$) Agent_list$) +(declare-fun product_lists$ (Event_list_list$) Event_list_list$) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent$)) (! (= (uue$ ?v0 ?v1) (member$ ?v1 ?v0)) :pattern ((uue$ ?v0 ?v1)))) :named a0)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (! (= (uuf$ ?v0 ?v1) (member$a ?v1 ?v0)) :pattern ((uuf$ ?v0 ?v1)))) :named a1)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event$)) (! (= (uud$ ?v0 ?v1) (member$b ?v1 ?v0)) :pattern ((uud$ ?v0 ?v1)))) :named a2)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (! (= (uuq$ ?v0 ?v1 ?v2) (ite (member$ ?v1 bad$) (insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0))) :pattern ((uuq$ ?v0 ?v1 ?v2)))) :named a3)) +(assert (! (forall ((?v0 Event_list_set$) (?v1 Event_list$) (?v2 Event$)) (! (= (uuj$ ?v0 ?v1 ?v2) (member$c (append$ ?v1 (cons$ ?v2 nil$)) ?v0)) :pattern ((uuj$ ?v0 ?v1 ?v2)))) :named a4)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (! (= (uun$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$ ?v2 ?v1))) :pattern ((uun$ ?v0 ?v1 ?v2)))) :named a5)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (! (= (uul$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$a ?v2 ?v1))) :pattern ((uul$ ?v0 ?v1 ?v2)))) :named a6)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (! (= (uum$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$b ?v2 ?v1))) :pattern ((uum$ ?v0 ?v1 ?v2)))) :named a7)) +(assert (! (forall ((?v0 Agent_set$) (?v1 (-> Agent$ Bool)) (?v2 Agent$)) (! (= (uub$ ?v0 ?v1 ?v2) (and (member$ ?v2 ?v0) (?v1 ?v2))) :pattern ((uub$ ?v0 ?v1 ?v2)))) :named a8)) +(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uuc$ ?v0 ?v1 ?v2) (and (member$a ?v2 ?v0) (?v1 ?v2))) :pattern ((uuc$ ?v0 ?v1 ?v2)))) :named a9)) +(assert (! (forall ((?v0 Event_set$) (?v1 (-> Event$ Bool)) (?v2 Event$)) (! (= (uua$ ?v0 ?v1 ?v2) (and (member$b ?v2 ?v0) (?v1 ?v2))) :pattern ((uua$ ?v0 ?v1 ?v2)))) :named a10)) +(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uu$ ?v0 ?v1 ?v2) (and (?v0 ?v2) (?v1 ?v2))) :pattern ((uu$ ?v0 ?v1 ?v2)))) :named a11)) +(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uuk$ ?v0 ?v1 ?v2) (=> (not (= ?v2 ?v0)) (?v1 ?v2))) :pattern ((uuk$ ?v0 ?v1 ?v2)))) :named a12)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event$)) (! (= (uui$ ?v0 ?v1 ?v2) (or (not (?v0 ?v2)) (= ?v1 ?v2))) :pattern ((uui$ ?v0 ?v1 ?v2)))) :named a13)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (! (= (uup$ ?v0 ?v1 ?v2) (knows$ spy$ ?v0)) :pattern ((uup$ ?v0 ?v1 ?v2)))) :named a14)) +(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (! (= (uus$ ?v0 ?v1 ?v2 ?v3) (ite (= ?v2 ?v0) (insert$ ?v3 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uus$ ?v0 ?v1 ?v2 ?v3)))) :named a15)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (! (= (uuo$ ?v0 ?v1 ?v2 ?v3) (insert$ ?v3 (knows$ spy$ ?v0))) :pattern ((uuo$ ?v0 ?v1 ?v2 ?v3)))) :named a16)) +(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Agent$) (?v4 Msg$)) (! (= (uur$ ?v0 ?v1 ?v2 ?v3 ?v4) (ite (= ?v2 ?v0) (insert$ ?v4 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uur$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a17)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (uug$ ?v0 ?v1) false) :pattern ((uug$ ?v0 ?v1)))) :named a18)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (uuh$ ?v0 ?v1) true) :pattern ((uuh$ ?v0 ?v1)))) :named a19)) +(assert (! (not (less_eq$ (knows$ spy$ (takeWhile$ p$ nil$)) (knows$ spy$ nil$))) :named a20)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (takeWhile$ ?v0 (takeWhile$ ?v0 ?v1)) (takeWhile$ ?v0 ?v1))) :named a21)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (=> (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))) (less_eq$a ?v0 ?v1))) :named a22)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (=> (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))) (less_eq$b ?v0 ?v1))) :named a23)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))) (less_eq$ ?v0 ?v1))) :named a24)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v0 ?v1))) :named a25)) +(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a26)) +(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (takeWhile$ ?v0 nil$) nil$) :pattern ((takeWhile$ ?v0)))) :named a27)) +(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool)) (?v2 (-> Msg$ Bool))) (= (less_eq$ ?v0 (collect$ (uu$ ?v1 ?v2))) (and (less_eq$ ?v0 (collect$ ?v1)) (less_eq$ ?v0 (collect$ ?v2))))) :named a28)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$) (?v3 (-> Event$ Bool))) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 (collect$a (uua$ ?v2 ?v3)))) (?v3 ?v0))) :named a29)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$) (?v3 (-> Agent$ Bool))) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 (collect$b (uub$ ?v2 ?v3)))) (?v3 ?v0))) :named a30)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$) (?v3 (-> Msg$ Bool))) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 (collect$ (uuc$ ?v2 ?v3)))) (?v3 ?v0))) :named a31)) +(assert (! (forall ((?v0 Event_set$) (?v1 (-> Event$ Bool))) (less_eq$a (collect$a (uua$ ?v0 ?v1)) ?v0)) :named a32)) +(assert (! (forall ((?v0 Agent_set$) (?v1 (-> Agent$ Bool))) (less_eq$b (collect$b (uub$ ?v0 ?v1)) ?v0)) :named a33)) +(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool))) (less_eq$ (collect$ (uuc$ ?v0 ?v1)) ?v0)) :named a34)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (less_eq$a ?v0 ?v1) (forall ((?v4 Event$)) (=> (and (member$b ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$a (collect$a (uua$ ?v0 ?v2)) (collect$a (uua$ ?v1 ?v3))))) :named a35)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (less_eq$b ?v0 ?v1) (forall ((?v4 Agent$)) (=> (and (member$ ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$b (collect$b (uub$ ?v0 ?v2)) (collect$b (uub$ ?v1 ?v3))))) :named a36)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (less_eq$ ?v0 ?v1) (forall ((?v4 Msg$)) (=> (and (member$a ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$ (collect$ (uuc$ ?v0 ?v2)) (collect$ (uuc$ ?v1 ?v3))))) :named a37)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool))) (=> (less_eq$a ?v0 ?v1) (= (less_eq$a ?v0 (collect$a (uua$ ?v1 ?v2))) (forall ((?v3 Event$)) (=> (member$b ?v3 ?v0) (?v2 ?v3)))))) :named a38)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool))) (=> (less_eq$b ?v0 ?v1) (= (less_eq$b ?v0 (collect$b (uub$ ?v1 ?v2))) (forall ((?v3 Agent$)) (=> (member$ ?v3 ?v0) (?v2 ?v3)))))) :named a39)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool))) (=> (less_eq$ ?v0 ?v1) (= (less_eq$ ?v0 (collect$ (uuc$ ?v1 ?v2))) (forall ((?v3 Msg$)) (=> (member$a ?v3 ?v0) (?v2 ?v3)))))) :named a40)) +(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (=> (not (= ?v0 nil$)) false)) false)) :named a41)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a42)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a43)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a44)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (less_eq$c (uud$ ?v0) (uud$ ?v1)))) :named a45)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (less_eq$d (uue$ ?v0) (uue$ ?v1)))) :named a46)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (less_eq$e (uuf$ ?v0) (uuf$ ?v1)))) :named a47)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v1 ?v0))) :named a48)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v2 ?v0)) (less_eq$ ?v2 ?v1))) :named a49)) +(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a50)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a51)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v0 ?v1))) :named a52)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (= ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a53)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (= ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a54)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (! (=> (less_eq$ ?v0 ?v1) (= (less_eq$ ?v1 ?v0) (= ?v1 ?v0))) :pattern ((less_eq$ ?v1 ?v0)))) :named a55)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a56)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v0 ?v1))) :named a57)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v0 ?v1))) :named a58)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (= ?v0 ?v1) (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)))) :named a59)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg_set$ Msg_set$)) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (and (= (?v2 ?v1) ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v2 ?v4) (?v2 ?v5)))))) (less_eq$ (?v2 ?v0) ?v3))) :named a60)) +(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg_set$ Msg_set$)) (?v2 Msg_set$) (?v3 Msg_set$)) (=> (and (= ?v0 (?v1 ?v2)) (and (less_eq$ ?v2 ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v1 ?v4) (?v1 ?v5)))))) (less_eq$ ?v0 (?v1 ?v3)))) :named a61)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg_set$ Msg_set$)) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (and (less_eq$ (?v2 ?v1) ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v2 ?v4) (?v2 ?v5)))))) (less_eq$ (?v2 ?v0) ?v3))) :named a62)) +(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg_set$ Msg_set$)) (?v2 Msg_set$) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 (?v1 ?v2)) (and (less_eq$ ?v2 ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v1 ?v4) (?v1 ?v5)))))) (less_eq$ ?v0 (?v1 ?v3)))) :named a63)) +(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool))) (= (less_eq$ (collect$ ?v0) (collect$ ?v1)) (forall ((?v2 Msg$)) (=> (?v0 ?v2) (?v1 ?v2))))) :named a64)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (not (member$b ?v2 ?v1))) (not (member$b ?v2 ?v0)))) :named a65)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (not (member$ ?v2 ?v1))) (not (member$ ?v2 ?v0)))) :named a66)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (not (member$a ?v2 ?v1))) (not (member$a ?v2 ?v0)))) :named a67)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (= ?v0 ?v1) (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)))) :named a68)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a69)) +(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool))) (=> (forall ((?v2 Msg$)) (=> (?v0 ?v2) (?v1 ?v2))) (less_eq$ (collect$ ?v0) (collect$ ?v1)))) :named a70)) +(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a71)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (member$b ?v0 ?v2))) :named a72)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (member$ ?v0 ?v2))) :named a73)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (member$a ?v0 ?v2))) :named a74)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))))) :named a75)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))))) :named a76)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))))) :named a77)) +(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (member$a ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a78)) +(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool))) (= (member$b ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a79)) +(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool))) (= (member$ ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a80)) +(assert (! (forall ((?v0 Msg_set$)) (= (collect$ (uuf$ ?v0)) ?v0)) :named a81)) +(assert (! (forall ((?v0 Event_set$)) (= (collect$a (uud$ ?v0)) ?v0)) :named a82)) +(assert (! (forall ((?v0 Agent_set$)) (= (collect$b (uue$ ?v0)) ?v0)) :named a83)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (member$b ?v0 ?v2))) :named a84)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (member$ ?v0 ?v2))) :named a85)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (member$a ?v0 ?v2))) :named a86)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v1 ?v0))) :named a87)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v0 ?v1))) :named a88)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))))) :named a89)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))))) :named a90)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))))) :named a91)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (= ?v0 ?v1) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) false)) false)) :named a92)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (and (=> (not (member$b ?v2 ?v0)) false) (=> (member$b ?v2 ?v1) false))) false)) :named a93)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (and (=> (not (member$ ?v2 ?v0)) false) (=> (member$ ?v2 ?v1) false))) false)) :named a94)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (and (=> (not (member$a ?v2 ?v0)) false) (=> (member$a ?v2 ?v1) false))) false)) :named a95)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a96)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a97)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a98)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a99)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a100)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a101)) +(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$c (uud$ ?v0) (uud$ ?v1)) (less_eq$a ?v0 ?v1))) :named a102)) +(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$d (uue$ ?v0) (uue$ ?v1)) (less_eq$b ?v0 ?v1))) :named a103)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$e (uuf$ ?v0) (uuf$ ?v1)) (less_eq$ ?v0 ?v1))) :named a104)) +(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (list_ex1$ ?v0 nil$) false) :pattern ((list_ex1$ ?v0)))) :named a105)) +(assert (! (forall ((?v0 (-> Event$ Event_list$))) (! (= (bind$ nil$ ?v0) nil$) :pattern ((bind$ nil$ ?v0)))) :named a106)) +(assert (! (forall ((?v0 (-> Msg_set$ Bool)) (?v1 Msg_set$)) (=> (and (?v0 ?v1) (forall ((?v2 Msg_set$)) (=> (?v0 ?v2) (less_eq$ ?v2 ?v1)))) (= (greatest$ ?v0) ?v1))) :named a107)) +(assert (! (forall ((?v0 (-> Msg_set$ Bool)) (?v1 Msg_set$) (?v2 (-> Msg_set$ Bool))) (=> (and (?v0 ?v1) (and (forall ((?v3 Msg_set$)) (=> (?v0 ?v3) (less_eq$ ?v3 ?v1))) (forall ((?v3 Msg_set$)) (=> (and (?v0 ?v3) (forall ((?v4 Msg_set$)) (=> (?v0 ?v4) (less_eq$ ?v4 ?v3)))) (?v2 ?v3))))) (?v2 (greatest$ ?v0)))) :named a108)) +(assert (! (forall ((?v0 Event$)) (! (= (member$d nil$ ?v0) false) :pattern ((member$d nil$ ?v0)))) :named a109)) +(assert (! (forall ((?v0 (-> Bool Msg_set$)) (?v1 (-> Bool Msg_set$))) (! (= (less_eq$f ?v0 ?v1) (and (less_eq$ (?v0 false) (?v1 false)) (less_eq$ (?v0 true) (?v1 true)))) :pattern ((less_eq$f ?v0 ?v1)))) :named a110)) +(assert (! (forall ((?v0 Nat$)) (! (= (gen_length$ ?v0 nil$) ?v0) :pattern ((gen_length$ ?v0)))) :named a111)) +(assert (! (forall ((?v0 (-> Event$ Event_list$))) (! (= (maps$ ?v0 nil$) nil$) :pattern ((maps$ ?v0)))) :named a112)) +(assert (! (forall ((?v0 Event_list$)) (= (= ?v0 nil$) (null$ ?v0))) :named a113)) +(assert (! (= (null$ nil$) true) :named a114)) +(assert (! (forall ((?v0 Event_list$)) (! (= (splice$ ?v0 nil$) ?v0) :pattern ((splice$ ?v0)))) :named a115)) +(assert (! (forall ((?v0 Event_list$)) (= (= (rotate1$ ?v0) nil$) (= ?v0 nil$))) :named a116)) +(assert (! (forall ((?v0 (-> Event$ Event_option$))) (! (= (map_filter$ ?v0 nil$) nil$) :pattern ((map_filter$ ?v0)))) :named a117)) +(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$)) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (antimono$ ?v0) (less_eq$ ?v1 ?v2)) (less_eq$ (?v0 ?v2) (?v0 ?v1)))) :named a118)) +(assert (! (= (rotate1$ nil$) nil$) :named a119)) +(assert (! (forall ((?v0 Event_list$)) (! (= (splice$ nil$ ?v0) ?v0) :pattern ((splice$ nil$ ?v0)))) :named a120)) +(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$))) (= (antimono$ ?v0) (forall ((?v1 Msg_set$) (?v2 Msg_set$)) (=> (less_eq$ ?v1 ?v2) (less_eq$ (?v0 ?v2) (?v0 ?v1)))))) :named a121)) +(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$))) (=> (forall ((?v1 Msg_set$) (?v2 Msg_set$)) (=> (less_eq$ ?v1 ?v2) (less_eq$ (?v0 ?v2) (?v0 ?v1)))) (antimono$ ?v0))) :named a122)) +(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$)) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (antimono$ ?v0) (and (less_eq$ ?v1 ?v2) (=> (less_eq$ (?v0 ?v2) (?v0 ?v1)) false))) false)) :named a123)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (=> (and (= (splice$ ?v0 ?v1) ?v2) (and (forall ((?v3 Event_list$)) (=> (and (= ?v0 nil$) (and (= ?v1 ?v3) (= ?v2 ?v3))) false)) (and (forall ((?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (cons$ ?v3 ?v4)) (and (= ?v1 nil$) (= ?v2 (cons$ ?v3 ?v4)))) false)) (forall ((?v3 Event$) (?v4 Event_list$) (?v5 Event$) (?v6 Event_list$)) (=> (and (= ?v0 (cons$ ?v3 ?v4)) (and (= ?v1 (cons$ ?v5 ?v6)) (= ?v2 (cons$ ?v3 (cons$ ?v5 (splice$ ?v4 ?v6)))))) false))))) false)) :named a124)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (splice$ (cons$ ?v0 ?v1) nil$) (cons$ ?v0 ?v1)) :pattern ((cons$ ?v0 ?v1)))) :named a125)) +(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (list_ex$ ?v0 nil$) false) :pattern ((list_ex$ ?v0)))) :named a126)) +(assert (! (forall ((?v0 Event_list$)) (= (= ?v0 nil$) (case_list$ true uug$ ?v0))) :named a127)) +(assert (! (forall ((?v0 Event_list$)) (= (not (= ?v0 nil$)) (case_list$ false uuh$ ?v0))) :named a128)) +(assert (! (forall ((?v0 Agent$)) (! (= (knows$ ?v0 nil$) (initState$ ?v0)) :pattern ((knows$ ?v0)))) :named a129)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$) (?v3 Event_list$)) (= (= (cons$ ?v0 ?v1) (cons$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a130)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (list_ex$ ?v0 (cons$ ?v1 ?v2)) (or (?v0 ?v1) (list_ex$ ?v0 ?v2))) :pattern ((list_ex$ ?v0 (cons$ ?v1 ?v2))))) :named a131)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (not (= (cons$ ?v0 ?v1) ?v1))) :named a132)) +(assert (! (forall ((?v0 Event_list_list$)) (=> (and (=> (= ?v0 nil$a) false) (and (forall ((?v1 Event_list_list$)) (=> (= ?v0 (cons$a nil$ ?v1)) false)) (forall ((?v1 Event$) (?v2 Event_list$) (?v3 Event_list_list$)) (=> (= ?v0 (cons$a (cons$ ?v1 ?v2) ?v3)) false)))) false)) :named a133)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (not (= nil$ (cons$ ?v0 ?v1)))) :named a134)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list$)) (=> (= ?v0 (cons$ ?v1 ?v2)) (not (= ?v0 nil$)))) :named a135)) +(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (forall ((?v1 Event$) (?v2 Event_list$)) (=> (= ?v0 (cons$ ?v1 ?v2)) false))) false)) :named a136)) +(assert (! (forall ((?v0 Event_list$)) (= (not (= ?v0 nil$)) (exists ((?v1 Event$) (?v2 Event_list$)) (= ?v0 (cons$ ?v1 ?v2))))) :named a137)) +(assert (! (forall ((?v0 (-> Event_list$ (-> Event_list$ Bool))) (?v1 Event_list$) (?v2 Event_list$)) (=> (and (?v0 nil$ nil$) (and (forall ((?v3 Event$) (?v4 Event_list$)) (?v0 (cons$ ?v3 ?v4) nil$)) (and (forall ((?v3 Event$) (?v4 Event_list$)) (?v0 nil$ (cons$ ?v3 ?v4))) (forall ((?v3 Event$) (?v4 Event_list$) (?v5 Event$) (?v6 Event_list$)) (=> (?v0 ?v4 ?v6) (?v0 (cons$ ?v3 ?v4) (cons$ ?v5 ?v6))))))) (?v0 ?v1 ?v2))) :named a138)) +(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (and (forall ((?v1 Event$)) (=> (= ?v0 (cons$ ?v1 nil$)) false)) (forall ((?v1 Event$) (?v2 Event$) (?v3 Event_list$)) (=> (= ?v0 (cons$ ?v1 (cons$ ?v2 ?v3))) false)))) false)) :named a139)) +(assert (! (forall ((?v0 (-> Event_list$ Bool)) (?v1 Event_list$)) (=> (and (?v0 nil$) (and (forall ((?v2 Event$)) (?v0 (cons$ ?v2 nil$))) (forall ((?v2 Event$) (?v3 Event$) (?v4 Event_list$)) (=> (?v0 (cons$ ?v3 ?v4)) (?v0 (cons$ ?v2 (cons$ ?v3 ?v4))))))) (?v0 ?v1))) :named a140)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event_list$ Bool))) (=> (and (not (= ?v0 nil$)) (and (forall ((?v2 Event$)) (?v1 (cons$ ?v2 nil$))) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (not (= ?v3 nil$)) (?v1 ?v3)) (?v1 (cons$ ?v2 ?v3)))))) (?v1 ?v0))) :named a141)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$) (?v3 Event_list$)) (! (= (splice$ (cons$ ?v0 ?v1) (cons$ ?v2 ?v3)) (cons$ ?v0 (cons$ ?v2 (splice$ ?v1 ?v3)))) :pattern ((splice$ (cons$ ?v0 ?v1) (cons$ ?v2 ?v3))))) :named a142)) +(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Event$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ ?v2 ?v1)))) :named a143)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (null$ (cons$ ?v0 ?v1)) false) :pattern ((cons$ ?v0 ?v1)))) :named a144)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (! (= (member$d (cons$ ?v0 ?v1) ?v2) (or (= ?v0 ?v2) (member$d ?v1 ?v2))) :pattern ((member$d (cons$ ?v0 ?v1) ?v2)))) :named a145)) +(assert (! (forall ((?v0 Agent$) (?v1 Event_list$)) (less_eq$ (initState$ ?v0) (knows$ ?v0 ?v1))) :named a146)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (takeWhile$ ?v0 (cons$ ?v1 ?v2)) (ite (?v0 ?v1) (cons$ ?v1 (takeWhile$ ?v0 ?v2)) nil$)) :pattern ((takeWhile$ ?v0 (cons$ ?v1 ?v2))))) :named a147)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (gets$ ?v1 ?v2) ?v0)))) :named a148)) +(assert (! (forall ((?v0 Event$)) (! (= (insert$a ?v0 nil$) (cons$ ?v0 nil$)) :pattern ((insert$a ?v0)))) :named a149)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (! (= (knows$ spy$ (cons$ (gets$ ?v0 ?v1) ?v2)) (knows$ spy$ ?v2)) :pattern ((cons$ (gets$ ?v0 ?v1) ?v2)))) :named a150)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (notes$ ?v1 ?v2) ?v0)))) :named a151)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (= (list_ex1$ ?v0 (cons$ ?v1 ?v2)) (ite (?v0 ?v1) (list_all$ (uui$ ?v0 ?v1) ?v2) (list_ex1$ ?v0 ?v2)))) :named a152)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Agent$) (?v3 Msg$)) (= (= (notes$ ?v0 ?v1) (notes$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a153)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Agent$) (?v3 Msg$)) (= (= (gets$ ?v0 ?v1) (gets$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a154)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (list_all$ ?v0 (cons$ ?v1 ?v2)) (and (?v0 ?v1) (list_all$ ?v0 ?v2))) :pattern ((list_all$ ?v0 (cons$ ?v1 ?v2))))) :named a155)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (list_all$ ?v0 (cons$ ?v1 ?v2)) (and (?v0 ?v1) (list_all$ ?v0 ?v2))) :pattern ((list_all$ ?v0 (cons$ ?v1 ?v2))))) :named a156)) +(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (list_all$ ?v0 nil$) true) :pattern ((list_all$ ?v0)))) :named a157)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Agent$) (?v3 Msg$)) (not (= (gets$ ?v0 ?v1) (notes$ ?v2 ?v3)))) :named a158)) +(assert (! (forall ((?v0 (-> Event$ Bool))) (list_all$ ?v0 nil$)) :named a159)) +(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ (notes$ ?v2 ?v3) ?v1)))) :named a160)) +(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ (gets$ ?v2 ?v3) ?v1)))) :named a161)) +(assert (! (= (product_lists$ nil$a) (cons$a nil$ nil$a)) :named a162)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (gets$ ?v1 ?v2) nil$))) (knows$ spy$ ?v0))) :named a163)) +(assert (! (= (subseqs$ nil$) (cons$a nil$ nil$a)) :named a164)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (says$ ?v1 ?v2 ?v3) ?v0)))) :named a165)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (append$ (append$ ?v0 ?v1) ?v2) (append$ ?v0 (append$ ?v1 ?v2)))) :named a166)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (append$ (append$ ?v0 ?v1) ?v2) (append$ ?v0 (append$ ?v1 ?v2)))) :named a167)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (= (append$ ?v0 ?v1) (append$ ?v2 ?v1)) (= ?v0 ?v2))) :named a168)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (= (append$ ?v0 ?v1) (append$ ?v0 ?v2)) (= ?v1 ?v2))) :named a169)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Agent$) (?v4 Agent$) (?v5 Msg$)) (= (= (says$ ?v0 ?v1 ?v2) (says$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a170)) +(assert (! (forall ((?v0 Event_list$)) (! (= (append$ ?v0 nil$) ?v0) :pattern ((append$ ?v0)))) :named a171)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= (append$ ?v0 ?v1) ?v0) (= ?v1 nil$))) :named a172)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= ?v0 (append$ ?v0 ?v1)) (= ?v1 nil$))) :named a173)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= (append$ ?v0 ?v1) ?v1) (= ?v0 nil$))) :named a174)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= ?v0 (append$ ?v1 ?v0)) (= ?v1 nil$))) :named a175)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= nil$ (append$ ?v0 ?v1)) (and (= ?v0 nil$) (= ?v1 nil$)))) :named a176)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= (append$ ?v0 ?v1) nil$) (and (= ?v0 nil$) (= ?v1 nil$)))) :named a177)) +(assert (! (forall ((?v0 Event_list$)) (! (= (append$ ?v0 nil$) ?v0) :pattern ((append$ ?v0)))) :named a178)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 Event_list$)) (= (list_all$ ?v0 (append$ ?v1 ?v2)) (and (list_all$ ?v0 ?v1) (list_all$ ?v0 ?v2)))) :named a179)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 Event_list$)) (= (list_ex$ ?v0 (append$ ?v1 ?v2)) (or (list_ex$ ?v0 ?v1) (list_ex$ ?v0 ?v2)))) :named a180)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list$) (?v3 Event$)) (= (= (append$ ?v0 (cons$ ?v1 nil$)) (append$ ?v2 (cons$ ?v3 nil$))) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a181)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 (-> Event$ Event_list$))) (! (= (bind$ (cons$ ?v0 ?v1) ?v2) (append$ (?v2 ?v0) (bind$ ?v1 ?v2))) :pattern ((bind$ (cons$ ?v0 ?v1) ?v2)))) :named a182)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$)) (! (= (append$ (cons$ ?v0 ?v1) ?v2) (cons$ ?v0 (append$ ?v1 ?v2))) :pattern ((append$ (cons$ ?v0 ?v1) ?v2)))) :named a183)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (= (cons$ ?v0 ?v1) ?v2) (= ?v3 (append$ ?v1 ?v4))) (= (cons$ ?v0 ?v3) (append$ ?v2 ?v4)))) :named a184)) +(assert (! (forall ((?v0 Event_list$)) (! (= (append$ nil$ ?v0) ?v0) :pattern ((append$ nil$ ?v0)))) :named a185)) +(assert (! (forall ((?v0 Event_list$)) (! (= (append$ nil$ ?v0) ?v0) :pattern ((append$ nil$ ?v0)))) :named a186)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (=> (= ?v0 ?v1) (= ?v0 (append$ nil$ ?v1)))) :named a187)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (= (append$ ?v0 ?v1) ?v2) (= ?v3 (append$ ?v1 ?v4))) (= (append$ ?v0 ?v3) (append$ ?v2 ?v4)))) :named a188)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$)) (= (= (append$ ?v0 ?v1) (append$ ?v2 ?v3)) (exists ((?v4 Event_list$)) (or (and (= ?v0 (append$ ?v2 ?v4)) (= (append$ ?v4 ?v1) ?v3)) (and (= (append$ ?v0 ?v4) ?v2) (= ?v1 (append$ ?v4 ?v3))))))) :named a189)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Agent$) (?v4 Msg$)) (not (= (says$ ?v0 ?v1 ?v2) (notes$ ?v3 ?v4)))) :named a190)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Agent$) (?v4 Msg$)) (not (= (says$ ?v0 ?v1 ?v2) (gets$ ?v3 ?v4)))) :named a191)) +(assert (! (forall ((?v0 (-> Event_list$ Bool)) (?v1 Event_list$)) (=> (and (?v0 nil$) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (?v0 ?v3) (?v0 (append$ ?v3 (cons$ ?v2 nil$)))))) (?v0 ?v1))) :named a192)) +(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (forall ((?v1 Event_list$) (?v2 Event$)) (=> (= ?v0 (append$ ?v1 (cons$ ?v2 nil$))) false))) false)) :named a193)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$)) (= (= (cons$ ?v0 ?v1) (append$ ?v2 ?v3)) (or (and (= ?v2 nil$) (= (cons$ ?v0 ?v1) ?v3)) (exists ((?v4 Event_list$)) (and (= (cons$ ?v0 ?v4) ?v2) (= ?v1 (append$ ?v4 ?v3))))))) :named a194)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event$) (?v3 Event_list$)) (= (= (append$ ?v0 ?v1) (cons$ ?v2 ?v3)) (or (and (= ?v0 nil$) (= ?v1 (cons$ ?v2 ?v3))) (exists ((?v4 Event_list$)) (and (= ?v0 (cons$ ?v2 ?v4)) (= (append$ ?v4 ?v1) ?v3)))))) :named a195)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event_list$ Bool))) (=> (and (not (= ?v0 nil$)) (and (forall ((?v2 Event$)) (?v1 (cons$ ?v2 nil$))) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (not (= ?v3 nil$)) (?v1 ?v3)) (?v1 (append$ ?v3 (cons$ ?v2 nil$))))))) (?v1 ?v0))) :named a196)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$) (?v3 Event_list$)) (=> (not (?v0 ?v1)) (= (takeWhile$ ?v0 (append$ ?v2 (cons$ ?v1 ?v3))) (takeWhile$ ?v0 ?v2)))) :named a197)) +(assert (! (forall ((?v0 Event$)) (=> (and (forall ((?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (=> (= ?v0 (says$ ?v1 ?v2 ?v3)) false)) (and (forall ((?v1 Agent$) (?v2 Msg$)) (=> (= ?v0 (gets$ ?v1 ?v2)) false)) (forall ((?v1 Agent$) (?v2 Msg$)) (=> (= ?v0 (notes$ ?v1 ?v2)) false)))) false)) :named a198)) +(assert (! (forall ((?v0 (-> Event$ Event_list$)) (?v1 Event$) (?v2 Event_list$)) (! (= (maps$ ?v0 (cons$ ?v1 ?v2)) (append$ (?v0 ?v1) (maps$ ?v0 ?v2))) :pattern ((maps$ ?v0 (cons$ ?v1 ?v2))))) :named a199)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (rotate1$ (cons$ ?v0 ?v1)) (append$ ?v1 (cons$ ?v0 nil$)))) :named a200)) +(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Agent$) (?v4 Msg$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ (says$ ?v2 ?v3 ?v4) ?v1)))) :named a201)) +(assert (! (forall ((?v0 Event_list_set$) (?v1 Event_list$)) (= (succ$ ?v0 ?v1) (collect$a (uuj$ ?v0 ?v1)))) :named a202)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (says$ ?v1 ?v2 ?v3) nil$))) (insert$ ?v3 (knows$ spy$ ?v0)))) :named a203)) +(assert (! (forall ((?v0 Msg$) (?v1 Agent$) (?v2 Event_list$)) (=> (and (member$a ?v0 (knows$ ?v1 ?v2)) (not (= ?v1 spy$))) (exists ((?v3 Agent$)) (or (member$b (says$ ?v1 ?v3 ?v0) (set$ ?v2)) (or (member$b (gets$ ?v1 ?v0) (set$ ?v2)) (or (member$b (notes$ ?v1 ?v0) (set$ ?v2)) (member$a ?v0 (initState$ ?v1)))))))) :named a204)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list_set$) (?v2 Msg_list$)) (=> (member$a ?v0 (succ$a ?v1 ?v2)) (member$e (append$a ?v2 (cons$b ?v0 nil$b)) ?v1))) :named a205)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list_set$) (?v2 Agent_list$)) (=> (member$ ?v0 (succ$b ?v1 ?v2)) (member$f (append$b ?v2 (cons$c ?v0 nil$c)) ?v1))) :named a206)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list_set$) (?v2 Event_list$)) (=> (member$b ?v0 (succ$ ?v1 ?v2)) (member$c (append$ ?v2 (cons$ ?v0 nil$)) ?v1))) :named a207)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (insert$ ?v0 (insert$ ?v0 ?v1)) (insert$ ?v0 ?v1))) :named a208)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (member$a ?v0 (insert$ ?v1 ?v2)) (or (= ?v0 ?v1) (member$a ?v0 ?v2)))) :named a209)) +(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (= (member$b ?v0 (insert$b ?v1 ?v2)) (or (= ?v0 ?v1) (member$b ?v0 ?v2)))) :named a210)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (= (member$ ?v0 (insert$c ?v1 ?v2)) (or (= ?v0 ?v1) (member$ ?v0 ?v2)))) :named a211)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (=> (not (member$a ?v0 ?v1)) (= ?v0 ?v2)) (member$a ?v0 (insert$ ?v2 ?v1)))) :named a212)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (=> (not (member$b ?v0 ?v1)) (= ?v0 ?v2)) (member$b ?v0 (insert$b ?v2 ?v1)))) :named a213)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (=> (not (member$ ?v0 ?v1)) (= ?v0 ?v2)) (member$ ?v0 (insert$c ?v2 ?v1)))) :named a214)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (= (less_eq$a (insert$b ?v0 ?v1) ?v2) (and (member$b ?v0 ?v2) (less_eq$a ?v1 ?v2)))) :named a215)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (= (less_eq$b (insert$c ?v0 ?v1) ?v2) (and (member$ ?v0 ?v2) (less_eq$b ?v1 ?v2)))) :named a216)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (= (less_eq$ (insert$ ?v0 ?v1) ?v2) (and (member$a ?v0 ?v2) (less_eq$ ?v1 ?v2)))) :named a217)) +(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (= (takeWhile$a ?v0 ?v1) ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 (set$a ?v1)) (?v0 ?v2))))) :named a218)) +(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (= (takeWhile$b ?v0 ?v1) ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 (set$b ?v1)) (?v0 ?v2))))) :named a219)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (= (takeWhile$ ?v0 ?v1) ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 (set$ ?v1)) (?v0 ?v2))))) :named a220)) +(assert (! (forall ((?v0 Event_list$)) (= (set$ (rotate1$ ?v0)) (set$ ?v0))) :named a221)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (member$a ?v0 (set$a ?v1)) (= (insert$d ?v0 ?v1) ?v1)) :pattern ((insert$d ?v0 ?v1)))) :named a222)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (member$ ?v0 (set$b ?v1)) (= (insert$e ?v0 ?v1) ?v1)) :pattern ((insert$e ?v0 ?v1)))) :named a223)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (member$b ?v0 (set$ ?v1)) (= (insert$a ?v0 ?v1) ?v1)) :pattern ((insert$a ?v0 ?v1)))) :named a224)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (set$a (cons$b ?v0 ?v1)) (insert$ ?v0 (set$a ?v1))) :pattern ((cons$b ?v0 ?v1)))) :named a225)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (set$ (cons$ ?v0 ?v1)) (insert$b ?v0 (set$ ?v1))) :pattern ((cons$ ?v0 ?v1)))) :named a226)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (forall ((?v3 Msg$)) (=> (member$a ?v3 (set$a ?v0)) (?v1 ?v3))) (= (takeWhile$a ?v1 (append$a ?v0 ?v2)) (append$a ?v0 (takeWhile$a ?v1 ?v2))))) :named a227)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (forall ((?v3 Agent$)) (=> (member$ ?v3 (set$b ?v0)) (?v1 ?v3))) (= (takeWhile$b ?v1 (append$b ?v0 ?v2)) (append$b ?v0 (takeWhile$b ?v1 ?v2))))) :named a228)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (forall ((?v3 Event$)) (=> (member$b ?v3 (set$ ?v0)) (?v1 ?v3))) (= (takeWhile$ ?v1 (append$ ?v0 ?v2)) (append$ ?v0 (takeWhile$ ?v1 ?v2))))) :named a229)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 Msg_list$)) (=> (and (member$a ?v0 (set$a ?v1)) (not (?v2 ?v0))) (= (takeWhile$a ?v2 (append$a ?v1 ?v3)) (takeWhile$a ?v2 ?v1)))) :named a230)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 Agent_list$)) (=> (and (member$ ?v0 (set$b ?v1)) (not (?v2 ?v0))) (= (takeWhile$b ?v2 (append$b ?v1 ?v3)) (takeWhile$b ?v2 ?v1)))) :named a231)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 Event_list$)) (=> (and (member$b ?v0 (set$ ?v1)) (not (?v2 ?v0))) (= (takeWhile$ ?v2 (append$ ?v1 ?v3)) (takeWhile$ ?v2 ?v1)))) :named a232)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set$a (insert$d ?v0 ?v1)) (insert$ ?v0 (set$a ?v1)))) :named a233)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set$ (insert$a ?v0 ?v1)) (insert$b ?v0 (set$ ?v1)))) :named a234)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (not (member$a ?v0 (set$a ?v1))) (= (insert$d ?v0 ?v1) (cons$b ?v0 ?v1))) :pattern ((insert$d ?v0 ?v1)))) :named a235)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (not (member$ ?v0 (set$b ?v1))) (= (insert$e ?v0 ?v1) (cons$c ?v0 ?v1))) :pattern ((insert$e ?v0 ?v1)))) :named a236)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (not (member$b ?v0 (set$ ?v1))) (= (insert$a ?v0 ?v1) (cons$ ?v0 ?v1))) :pattern ((insert$a ?v0 ?v1)))) :named a237)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (! (= (knows$ spy$ (cons$ (says$ ?v0 ?v1 ?v2) ?v3)) (insert$ ?v2 (knows$ spy$ ?v3))) :pattern ((cons$ (says$ ?v0 ?v1 ?v2) ?v3)))) :named a238)) +(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_set$)) (= (less_eq$b (set$b ?v0) ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 (set$b ?v0)) (member$ ?v2 ?v1))))) :named a239)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_set$)) (= (less_eq$a (set$ ?v0) ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 (set$ ?v0)) (member$b ?v2 ?v1))))) :named a240)) +(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_set$)) (= (less_eq$ (set$a ?v0) ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 (set$a ?v0)) (member$a ?v2 ?v1))))) :named a241)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v2 ?v1)) (less_eq$a (insert$b ?v0 ?v2) ?v1))) :named a242)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v2 ?v1)) (less_eq$b (insert$c ?v0 ?v2) ?v1))) :named a243)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v2 ?v1)) (less_eq$ (insert$ ?v0 ?v2) ?v1))) :named a244)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ ?v0 (insert$ ?v2 ?v1)))) :named a245)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (less_eq$ ?v0 (insert$ ?v1 ?v0))) :named a246)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (not (member$b ?v0 ?v1)) (= (less_eq$a ?v1 (insert$b ?v0 ?v2)) (less_eq$a ?v1 ?v2)))) :named a247)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (not (member$ ?v0 ?v1)) (= (less_eq$b ?v1 (insert$c ?v0 ?v2)) (less_eq$b ?v1 ?v2)))) :named a248)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (not (member$a ?v0 ?v1)) (= (less_eq$ ?v1 (insert$ ?v0 ?v2)) (less_eq$ ?v1 ?v2)))) :named a249)) +(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ (insert$ ?v2 ?v0) (insert$ ?v2 ?v1)))) :named a250)) +(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$a ?v2 ?v0) (list_ex$a ?v3 ?v1)))) :named a251)) +(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$b ?v2 ?v0) (list_ex$b ?v3 ?v1)))) :named a252)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$ ?v2 ?v0) (list_ex$ ?v3 ?v1)))) :named a253)) +(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (insert$ ?v0 (collect$ ?v1)) (collect$ (uuk$ ?v0 ?v1)))) :named a254)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (insert$ ?v0 ?v1) (collect$ (uul$ ?v0 ?v1)))) :named a255)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (= (insert$b ?v0 ?v1) (collect$a (uum$ ?v0 ?v1)))) :named a256)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (= (insert$c ?v0 ?v1) (collect$b (uun$ ?v0 ?v1)))) :named a257)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (member$a ?v0 ?v1) (exists ((?v2 Msg_set$)) (and (= ?v1 (insert$ ?v0 ?v2)) (not (member$a ?v0 ?v2)))))) :named a258)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (member$b ?v0 ?v1) (exists ((?v2 Event_set$)) (and (= ?v1 (insert$b ?v0 ?v2)) (not (member$b ?v0 ?v2)))))) :named a259)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (member$ ?v0 ?v1) (exists ((?v2 Agent_set$)) (and (= ?v1 (insert$c ?v0 ?v2)) (not (member$ ?v0 ?v2)))))) :named a260)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (insert$ ?v0 (insert$ ?v1 ?v2)) (insert$ ?v1 (insert$ ?v0 ?v2)))) :named a261)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$) (?v3 Msg_set$)) (=> (and (not (member$a ?v0 ?v1)) (not (member$a ?v2 ?v3))) (= (= (insert$ ?v0 ?v1) (insert$ ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Msg_set$)) (and (= ?v1 (insert$ ?v2 ?v4)) (and (not (member$a ?v2 ?v4)) (and (= ?v3 (insert$ ?v0 ?v4)) (not (member$a ?v0 ?v4)))))))))) :named a262)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$) (?v3 Event_set$)) (=> (and (not (member$b ?v0 ?v1)) (not (member$b ?v2 ?v3))) (= (= (insert$b ?v0 ?v1) (insert$b ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Event_set$)) (and (= ?v1 (insert$b ?v2 ?v4)) (and (not (member$b ?v2 ?v4)) (and (= ?v3 (insert$b ?v0 ?v4)) (not (member$b ?v0 ?v4)))))))))) :named a263)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$) (?v3 Agent_set$)) (=> (and (not (member$ ?v0 ?v1)) (not (member$ ?v2 ?v3))) (= (= (insert$c ?v0 ?v1) (insert$c ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Agent_set$)) (and (= ?v1 (insert$c ?v2 ?v4)) (and (not (member$ ?v2 ?v4)) (and (= ?v3 (insert$c ?v0 ?v4)) (not (member$ ?v0 ?v4)))))))))) :named a264)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (! (=> (member$a ?v0 ?v1) (= (insert$ ?v0 ?v1) ?v1)) :pattern ((insert$ ?v0 ?v1)))) :named a265)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (! (=> (member$b ?v0 ?v1) (= (insert$b ?v0 ?v1) ?v1)) :pattern ((insert$b ?v0 ?v1)))) :named a266)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (! (=> (member$ ?v0 ?v1) (= (insert$c ?v0 ?v1) ?v1)) :pattern ((insert$c ?v0 ?v1)))) :named a267)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (not (member$a ?v0 ?v1)) (not (member$a ?v0 ?v2))) (= (= (insert$ ?v0 ?v1) (insert$ ?v0 ?v2)) (= ?v1 ?v2)))) :named a268)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (not (member$b ?v0 ?v1)) (not (member$b ?v0 ?v2))) (= (= (insert$b ?v0 ?v1) (insert$b ?v0 ?v2)) (= ?v1 ?v2)))) :named a269)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (not (member$ ?v0 ?v1)) (not (member$ ?v0 ?v2))) (= (= (insert$c ?v0 ?v1) (insert$c ?v0 ?v2)) (= ?v1 ?v2)))) :named a270)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (and (member$a ?v0 ?v1) (forall ((?v2 Msg_set$)) (=> (and (= ?v1 (insert$ ?v0 ?v2)) (not (member$a ?v0 ?v2))) false))) false)) :named a271)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (and (member$b ?v0 ?v1) (forall ((?v2 Event_set$)) (=> (and (= ?v1 (insert$b ?v0 ?v2)) (not (member$b ?v0 ?v2))) false))) false)) :named a272)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (and (member$ ?v0 ?v1) (forall ((?v2 Agent_set$)) (=> (and (= ?v1 (insert$c ?v0 ?v2)) (not (member$ ?v0 ?v2))) false))) false)) :named a273)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (member$a ?v0 ?v1) (member$a ?v0 (insert$ ?v2 ?v1)))) :named a274)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (member$b ?v0 ?v1) (member$b ?v0 (insert$b ?v2 ?v1)))) :named a275)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (member$ ?v0 ?v1) (member$ ?v0 (insert$c ?v2 ?v1)))) :named a276)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (member$a ?v0 (insert$ ?v0 ?v1))) :named a277)) +(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (member$b ?v0 (insert$b ?v0 ?v1))) :named a278)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (member$ ?v0 (insert$c ?v0 ?v1))) :named a279)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (=> (and (member$a ?v0 (insert$ ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$a ?v0 ?v2) false))) false)) :named a280)) +(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (=> (and (member$b ?v0 (insert$b ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$b ?v0 ?v2) false))) false)) :named a281)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (=> (and (member$ ?v0 (insert$c ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$ ?v0 ?v2) false))) false)) :named a282)) +(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (member$a ?v0 (set$a (takeWhile$a ?v1 ?v2))) (and (member$a ?v0 (set$a ?v2)) (?v1 ?v0)))) :named a283)) +(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (member$ ?v0 (set$b (takeWhile$b ?v1 ?v2))) (and (member$ ?v0 (set$b ?v2)) (?v1 ?v0)))) :named a284)) +(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (member$b ?v0 (set$ (takeWhile$ ?v1 ?v2))) (and (member$b ?v0 (set$ ?v2)) (?v1 ?v0)))) :named a285)) +(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$a ?v2 ?v0) (takeWhile$a ?v3 ?v1)))) :named a286)) +(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$b ?v2 ?v0) (takeWhile$b ?v3 ?v1)))) :named a287)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$ ?v2 ?v0) (takeWhile$ ?v3 ?v1)))) :named a288)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg$)) (=> (member$a ?v0 (set$a ?v1)) (member$a ?v0 (set$a (cons$b ?v2 ?v1))))) :named a289)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent$)) (=> (member$ ?v0 (set$b ?v1)) (member$ ?v0 (set$b (cons$c ?v2 ?v1))))) :named a290)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (=> (member$b ?v0 (set$ ?v1)) (member$b ?v0 (set$ (cons$ ?v2 ?v1))))) :named a291)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (member$a ?v0 (set$a (cons$b ?v0 ?v1)))) :named a292)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (member$ ?v0 (set$b (cons$c ?v0 ?v1)))) :named a293)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (member$b ?v0 (set$ (cons$ ?v0 ?v1)))) :named a294)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_list$)) (=> (member$a ?v0 (set$a (cons$b ?v1 ?v2))) (or (= ?v0 ?v1) (member$a ?v0 (set$a ?v2))))) :named a295)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_list$)) (=> (member$ ?v0 (set$b (cons$c ?v1 ?v2))) (or (= ?v0 ?v1) (member$ ?v0 (set$b ?v2))))) :named a296)) +(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_list$)) (=> (member$b ?v0 (set$ (cons$ ?v1 ?v2))) (or (= ?v0 ?v1) (member$b ?v0 (set$ ?v2))))) :named a297)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (and (member$a ?v0 (set$a ?v1)) (and (forall ((?v2 Msg_list$)) (=> (= ?v1 (cons$b ?v0 ?v2)) false)) (forall ((?v2 Msg$) (?v3 Msg_list$)) (=> (and (= ?v1 (cons$b ?v2 ?v3)) (member$a ?v0 (set$a ?v3))) false)))) false)) :named a298)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (and (member$ ?v0 (set$b ?v1)) (and (forall ((?v2 Agent_list$)) (=> (= ?v1 (cons$c ?v0 ?v2)) false)) (forall ((?v2 Agent$) (?v3 Agent_list$)) (=> (and (= ?v1 (cons$c ?v2 ?v3)) (member$ ?v0 (set$b ?v3))) false)))) false)) :named a299)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (and (member$b ?v0 (set$ ?v1)) (and (forall ((?v2 Event_list$)) (=> (= ?v1 (cons$ ?v0 ?v2)) false)) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (= ?v1 (cons$ ?v2 ?v3)) (member$b ?v0 (set$ ?v3))) false)))) false)) :named a300)) +(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$a ?v2 ?v0) (list_all$a ?v3 ?v1)))) :named a301)) +(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$b ?v2 ?v0) (list_all$b ?v3 ?v1)))) :named a302)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$ ?v2 ?v0) (list_all$ ?v3 ?v1)))) :named a303)) +(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$) (?v2 (-> Msg$ Bool))) (=> (and (list_all$a ?v0 ?v1) (forall ((?v3 Msg$)) (=> (and (member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$a ?v2 ?v1))) :named a304)) +(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$) (?v2 (-> Agent$ Bool))) (=> (and (list_all$b ?v0 ?v1) (forall ((?v3 Agent$)) (=> (and (member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$b ?v2 ?v1))) :named a305)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 (-> Event$ Bool))) (=> (and (list_all$ ?v0 ?v1) (forall ((?v3 Event$)) (=> (and (member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$ ?v2 ?v1))) :named a306)) +(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (list_ex1$a ?v0 ?v1) (exists ((?v2 Msg$)) (and (and (member$a ?v2 (set$a ?v1)) (?v0 ?v2)) (forall ((?v3 Msg$)) (=> (and (member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a307)) +(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (list_ex1$b ?v0 ?v1) (exists ((?v2 Agent$)) (and (and (member$ ?v2 (set$b ?v1)) (?v0 ?v2)) (forall ((?v3 Agent$)) (=> (and (member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a308)) +(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (list_ex1$ ?v0 ?v1) (exists ((?v2 Event$)) (and (and (member$b ?v2 (set$ ?v1)) (?v0 ?v2)) (forall ((?v3 Event$)) (=> (and (member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a309)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (member$g ?v1 ?v0))) :named a310)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (member$h ?v1 ?v0))) :named a311)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (member$d ?v1 ?v0))) :named a312)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event$)) (less_eq$a (set$ ?v0) (set$ (cons$ ?v1 ?v0)))) :named a313)) +(assert (! (forall ((?v0 Msg_list$) (?v1 Msg$)) (less_eq$ (set$a ?v0) (set$a (cons$b ?v1 ?v0)))) :named a314)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a315)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a316)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a317)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a318)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a319)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a320)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v2))))))) :named a321)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v2))))))) :named a322)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v2))))))) :named a323)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v3))))))) :named a324)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v3))))))) :named a325)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v3))))))) :named a326)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a327)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a328)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a329)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a330)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a331)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a332)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a333)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a334)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a335)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a336)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a337)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a338)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a339)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a340)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a341)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg_list$) (?v3 Msg_list$) (?v4 Msg_list$)) (=> (and (not (member$a ?v0 (set$a ?v1))) (not (member$a ?v0 (set$a ?v2)))) (= (= (append$a ?v1 (cons$b ?v0 ?v2)) (append$a ?v3 (cons$b ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a342)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent_list$) (?v3 Agent_list$) (?v4 Agent_list$)) (=> (and (not (member$ ?v0 (set$b ?v1))) (not (member$ ?v0 (set$b ?v2)))) (= (= (append$b ?v1 (cons$c ?v0 ?v2)) (append$b ?v3 (cons$c ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a343)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (not (member$b ?v0 (set$ ?v1))) (not (member$b ?v0 (set$ ?v2)))) (= (= (append$ ?v1 (cons$ ?v0 ?v2)) (append$ ?v3 (cons$ ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a344)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a345)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a346)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a347)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v2))))))) :named a348)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v2))))))) :named a349)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v2))))))) :named a350)) +(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3))))) :named a351)) +(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3))))) :named a352)) +(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3))))) :named a353)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v3))))))) :named a354)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v3))))))) :named a355)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v3))))))) :named a356)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a357)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a358)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a359)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (member$a ?v2 (knows$ ?v0 ?v3)))) :named a360)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (member$b (notes$ ?v0 ?v1) (set$ ?v2)) (member$a ?v1 (knows$ ?v0 ?v2)))) :named a361)) +(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (insert$d ?v0 ?v1) (ite (member$a ?v0 (set$a ?v1)) ?v1 (cons$b ?v0 ?v1))) :pattern ((insert$d ?v0 ?v1)))) :named a362)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (= (insert$e ?v0 ?v1) (ite (member$ ?v0 (set$b ?v1)) ?v1 (cons$c ?v0 ?v1))) :pattern ((insert$e ?v0 ?v1)))) :named a363)) +(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (insert$a ?v0 ?v1) (ite (member$b ?v0 (set$ ?v1)) ?v1 (cons$ ?v0 ?v1))) :pattern ((insert$a ?v0 ?v1)))) :named a364)) +(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (member$a ?v2 (knows$ spy$ ?v3)))) :named a365)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (not (= ?v0 spy$)) (member$b (gets$ ?v0 ?v1) (set$ ?v2))) (member$a ?v1 (knows$ ?v0 ?v2)))) :named a366)) +(assert (! (forall ((?v0 Msg$) (?v1 Event_list$)) (=> (member$a ?v0 (knows$ spy$ ?v1)) (exists ((?v2 Agent$) (?v3 Agent$)) (or (member$b (says$ ?v2 ?v3 ?v0) (set$ ?v1)) (or (member$b (notes$ ?v2 ?v0) (set$ ?v1)) (member$a ?v0 (initState$ spy$))))))) :named a367)) +(assert (! (forall ((?v0 Msg_list$) (?v1 Msg$) (?v2 Msg_list_set$)) (=> (member$e (append$a ?v0 (cons$b ?v1 nil$b)) ?v2) (member$a ?v1 (succ$a ?v2 ?v0)))) :named a368)) +(assert (! (forall ((?v0 Agent_list$) (?v1 Agent$) (?v2 Agent_list_set$)) (=> (member$f (append$b ?v0 (cons$c ?v1 nil$c)) ?v2) (member$ ?v1 (succ$b ?v2 ?v0)))) :named a369)) +(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list_set$)) (=> (member$c (append$ ?v0 (cons$ ?v1 nil$)) ?v2) (member$b ?v1 (succ$ ?v2 ?v0)))) :named a370)) +(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (notes$ ?v1 ?v2) nil$))) (ite (member$ ?v1 bad$) (insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0)))) :named a371)) +(assert (! (member$ spy$ bad$) :named a372)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (! (= (knows$ spy$ (cons$ (notes$ ?v0 ?v1) ?v2)) (ite (member$ ?v0 bad$) (insert$ ?v1 (knows$ spy$ ?v2)) (knows$ spy$ ?v2))) :pattern ((cons$ (notes$ ?v0 ?v1) ?v2)))) :named a373)) +(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (member$b (notes$ ?v0 ?v1) (set$ ?v2)) (member$ ?v0 bad$)) (member$a ?v1 (knows$ spy$ ?v2)))) :named a374)) +(assert (! (forall ((?v0 Agent$) (?v1 Event$) (?v2 Event_list$)) (= (knows$ ?v0 (cons$ ?v1 ?v2)) (ite (= ?v0 spy$) (case_event$ (uuo$ ?v2) (uup$ ?v2) (uuq$ ?v2) ?v1) (case_event$ (uur$ ?v0 ?v2) (uus$ ?v0 ?v2) (uus$ ?v0 ?v2) ?v1)))) :named a375)) +(check-sat) diff --git a/test/regress/regress1/ho/fta0409.smt2 b/test/regress/regress1/ho/fta0409.smt2 new file mode 100644 index 000000000..51ac5f2da --- /dev/null +++ b/test/regress/regress1/ho/fta0409.smt2 @@ -0,0 +1,427 @@ +; COMMAND-LINE: --uf-ho +; EXPECT: unsat +(set-logic ALL) +(set-info :status unsat) +(declare-sort Nat$ 0) +(declare-sort Complex$ 0) +(declare-sort Nat_poly$ 0) +(declare-sort Complex_poly$ 0) +(declare-sort Complex_poly_poly$ 0) +(declare-fun n$ () Nat$) +(declare-fun q$ () Complex_poly$) +(declare-fun r$ () Complex_poly$) +(declare-fun dvd$ (Complex_poly$ Complex_poly$) Bool) +(declare-fun one$ () Nat$) +(declare-fun suc$ (Nat$) Nat$) +(declare-fun dvd$a (Complex$ Complex$) Bool) +(declare-fun dvd$b (Nat$ Nat$) Bool) +(declare-fun dvd$c (Complex_poly_poly$ Complex_poly_poly$) Bool) +(declare-fun dvd$d (Nat_poly$ Nat_poly$) Bool) +(declare-fun one$a () Complex_poly$) +(declare-fun one$b () Complex$) +(declare-fun one$c () Nat_poly$) +(declare-fun plus$ (Complex$ Complex$) Complex$) +(declare-fun poly$ (Complex_poly$) (-> Complex$ Complex$)) +(declare-fun zero$ () Complex$) +(declare-fun coeff$ (Complex_poly_poly$ Nat$) Complex_poly$) +(declare-fun monom$ (Complex$ Nat$) Complex_poly$) +(declare-fun order$ (Complex$ Complex_poly$) Nat$) +(declare-fun pCons$ (Complex$ Complex_poly$) Complex_poly$) +(declare-fun plus$a (Nat$ Nat$) Nat$) +(declare-fun plus$b (Nat_poly$ Nat_poly$) Nat_poly$) +(declare-fun plus$c (Complex_poly$ Complex_poly$) Complex_poly$) +(declare-fun poly$a (Complex_poly_poly$ Complex_poly$) Complex_poly$) +(declare-fun poly$b (Nat_poly$ Nat$) Nat$) +(declare-fun power$ (Complex_poly$ Nat$) Complex_poly$) +(declare-fun psize$ (Complex_poly$) Nat$) +(declare-fun times$ (Nat$ Nat$) Nat$) +(declare-fun zero$a () Nat$) +(declare-fun zero$b () Complex_poly_poly$) +(declare-fun zero$c () Complex_poly$) +(declare-fun zero$d () Nat_poly$) +(declare-fun coeff$a (Nat_poly$ Nat$) Nat$) +(declare-fun coeff$b (Complex_poly$ Nat$) Complex$) +(declare-fun degree$ (Complex_poly_poly$) Nat$) +(declare-fun monom$a (Complex_poly$ Nat$) Complex_poly_poly$) +(declare-fun monom$b (Nat$ Nat$) Nat_poly$) +(declare-fun order$a (Complex_poly$ Complex_poly_poly$) Nat$) +(declare-fun pCons$a (Complex_poly$ Complex_poly_poly$) Complex_poly_poly$) +(declare-fun pCons$b (Nat$ Nat_poly$) Nat_poly$) +(declare-fun power$a (Complex_poly_poly$ Nat$) Complex_poly_poly$) +(declare-fun power$b (Nat_poly$ Nat$) Nat_poly$) +(declare-fun power$c (Nat$ Nat$) Nat$) +(declare-fun power$d (Complex$ Nat$) Complex$) +(declare-fun degree$a (Nat_poly$) Nat$) +(declare-fun degree$b (Complex_poly$) Nat$) +(declare-fun is_zero$ (Complex_poly$) Bool) +(declare-fun less_eq$ (Nat$ Nat$) Bool) +(declare-fun of_bool$ (Bool) Complex$) +(declare-fun constant$ ((-> Complex$ Complex$)) Bool) +(declare-fun of_bool$a (Bool) Complex_poly$) +(declare-fun of_bool$b (Bool) Nat$) +(declare-fun pcompose$ (Complex_poly$ Complex_poly$) Complex_poly$) +(declare-fun pcompose$a (Complex_poly_poly$ Complex_poly_poly$) Complex_poly_poly$) +(declare-fun pcompose$b (Nat_poly$ Nat_poly$) Nat_poly$) +(declare-fun poly_shift$ (Nat$ Complex_poly$) Complex_poly$) +(declare-fun offset_poly$ (Complex_poly$ Complex$) Complex_poly$) +(declare-fun poly_cutoff$ (Nat$ Complex_poly$) Complex_poly$) +(declare-fun rsquarefree$ (Complex_poly$) Bool) +(declare-fun offset_poly$a (Nat_poly$ Nat$) Nat_poly$) +(declare-fun reflect_poly$ (Complex_poly$) Complex_poly$) +(declare-fun reflect_poly$a (Complex_poly_poly$) Complex_poly_poly$) +(declare-fun reflect_poly$b (Nat_poly$) Nat_poly$) +(declare-fun synthetic_div$ (Complex_poly$ Complex$) Complex_poly$) +(assert (! (not (= (poly$ (power$ q$ n$)) (poly$ r$))) :named a0)) +(assert (! (forall ((?v0 Complex$)) (= (poly$ (power$ q$ n$) ?v0) (poly$ r$ ?v0))) :named a1)) +(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Nat$) (?v2 Complex_poly$)) (= (poly$a (power$a ?v0 ?v1) ?v2) (power$ (poly$a ?v0 ?v2) ?v1))) :named a2)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$) (?v2 Nat$)) (= (poly$b (power$b ?v0 ?v1) ?v2) (power$c (poly$b ?v0 ?v2) ?v1))) :named a3)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Complex$)) (= (poly$ (power$ ?v0 ?v1) ?v2) (power$d (poly$ ?v0 ?v2) ?v1))) :named a4)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= (poly$ ?v0) (poly$ ?v1)) (= ?v0 ?v1))) :named a5)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (not (constant$ (poly$ ?v0))) (exists ((?v1 Complex$)) (= (poly$ ?v0 ?v1) zero$)))) :named a6)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (reflect_poly$ (power$ ?v0 ?v1)) (power$ (reflect_poly$ ?v0) ?v1))) :named a7)) +(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Nat$)) (= (coeff$ (power$a ?v0 ?v1) zero$a) (power$ (coeff$ ?v0 zero$a) ?v1))) :named a8)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$)) (= (coeff$a (power$b ?v0 ?v1) zero$a) (power$c (coeff$a ?v0 zero$a) ?v1))) :named a9)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (coeff$b (power$ ?v0 ?v1) zero$a) (power$d (coeff$b ?v0 zero$a) ?v1))) :named a10)) +(assert (! (forall ((?v0 (-> Complex$ Complex$))) (= (constant$ ?v0) (forall ((?v1 Complex$) (?v2 Complex$)) (= (?v0 ?v1) (?v0 ?v2))))) :named a11)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (exists ((?v2 Complex_poly$)) (and (= (psize$ ?v2) (psize$ ?v0)) (forall ((?v3 Complex$)) (= (poly$ ?v2 ?v3) (poly$ ?v0 (plus$ ?v1 ?v3))))))) :named a12)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$) (?v2 Complex$)) (= (poly$ (offset_poly$ ?v0 ?v1) ?v2) (poly$ ?v0 (plus$ ?v1 ?v2)))) :named a13)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$) (?v2 Nat$)) (= (poly$b (offset_poly$a ?v0 ?v1) ?v2) (poly$b ?v0 (plus$a ?v1 ?v2)))) :named a14)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex$)) (= (poly$ (pcompose$ ?v0 ?v1) ?v2) (poly$ ?v0 (poly$ ?v1 ?v2)))) :named a15)) +(assert (! (forall ((?v0 Complex_poly$)) (= (power$ ?v0 one$) ?v0)) :named a16)) +(assert (! (forall ((?v0 Nat$)) (= (power$c ?v0 one$) ?v0)) :named a17)) +(assert (! (forall ((?v0 Nat$)) (= (power$ one$a ?v0) one$a)) :named a18)) +(assert (! (forall ((?v0 Nat$)) (= (power$c one$ ?v0) one$)) :named a19)) +(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Nat$)) (= (coeff$ (power$a ?v0 ?v1) (degree$ (power$a ?v0 ?v1))) (power$ (coeff$ ?v0 (degree$ ?v0)) ?v1))) :named a20)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$)) (= (coeff$a (power$b ?v0 ?v1) (degree$a (power$b ?v0 ?v1))) (power$c (coeff$a ?v0 (degree$a ?v0)) ?v1))) :named a21)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (coeff$b (power$ ?v0 ?v1) (degree$b (power$ ?v0 ?v1))) (power$d (coeff$b ?v0 (degree$b ?v0)) ?v1))) :named a22)) +(assert (! (forall ((?v0 Nat$)) (= (coeff$ zero$b ?v0) zero$c)) :named a23)) +(assert (! (forall ((?v0 Nat$)) (= (coeff$a zero$d ?v0) zero$a)) :named a24)) +(assert (! (forall ((?v0 Nat$)) (= (coeff$b zero$c ?v0) zero$)) :named a25)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat_poly$) (?v2 Nat$)) (= (coeff$a (plus$b ?v0 ?v1) ?v2) (plus$a (coeff$a ?v0 ?v2) (coeff$a ?v1 ?v2)))) :named a26)) +(assert (! (forall ((?v0 Complex_poly$)) (= (poly$a zero$b ?v0) zero$c)) :named a27)) +(assert (! (forall ((?v0 Nat$)) (= (poly$b zero$d ?v0) zero$a)) :named a28)) +(assert (! (forall ((?v0 Complex$)) (= (poly$ zero$c ?v0) zero$)) :named a29)) +(assert (! (= (degree$b one$a) zero$a) :named a30)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex$)) (= (poly$ (plus$c ?v0 ?v1) ?v2) (plus$ (poly$ ?v0 ?v2) (poly$ ?v1 ?v2)))) :named a31)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat_poly$) (?v2 Nat$)) (= (poly$b (plus$b ?v0 ?v1) ?v2) (plus$a (poly$b ?v0 ?v2) (poly$b ?v1 ?v2)))) :named a32)) +(assert (! (forall ((?v0 Complex$)) (= (poly$ one$a ?v0) one$b)) :named a33)) +(assert (! (forall ((?v0 Nat$)) (= (poly$b one$c ?v0) one$)) :named a34)) +(assert (! (forall ((?v0 Complex_poly$)) (= (= (coeff$b ?v0 (degree$b ?v0)) zero$) (= ?v0 zero$c))) :named a35)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (= (coeff$ ?v0 (degree$ ?v0)) zero$c) (= ?v0 zero$b))) :named a36)) +(assert (! (forall ((?v0 Nat_poly$)) (= (= (coeff$a ?v0 (degree$a ?v0)) zero$a) (= ?v0 zero$d))) :named a37)) +(assert (! (= (coeff$b one$a (degree$b one$a)) one$b) :named a38)) +(assert (! (= (coeff$a one$c (degree$a one$c)) one$) :named a39)) +(assert (! (forall ((?v0 Complex_poly$)) (= (= (poly$ (reflect_poly$ ?v0) zero$) zero$) (= ?v0 zero$c))) :named a40)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (= (poly$a (reflect_poly$a ?v0) zero$c) zero$c) (= ?v0 zero$b))) :named a41)) +(assert (! (forall ((?v0 Nat_poly$)) (= (= (poly$b (reflect_poly$b ?v0) zero$a) zero$a) (= ?v0 zero$d))) :named a42)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= (coeff$b ?v0 zero$a) zero$)) (= (reflect_poly$ (reflect_poly$ ?v0)) ?v0))) :named a43)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (=> (not (= (coeff$ ?v0 zero$a) zero$c)) (= (reflect_poly$a (reflect_poly$a ?v0)) ?v0))) :named a44)) +(assert (! (forall ((?v0 Nat_poly$)) (=> (not (= (coeff$a ?v0 zero$a) zero$a)) (= (reflect_poly$b (reflect_poly$b ?v0)) ?v0))) :named a45)) +(assert (! (forall ((?v0 Complex_poly$)) (= (= (coeff$b (reflect_poly$ ?v0) zero$a) zero$) (= ?v0 zero$c))) :named a46)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (= (coeff$ (reflect_poly$a ?v0) zero$a) zero$c) (= ?v0 zero$b))) :named a47)) +(assert (! (forall ((?v0 Nat_poly$)) (= (= (coeff$a (reflect_poly$b ?v0) zero$a) zero$a) (= ?v0 zero$d))) :named a48)) +(assert (! (forall ((?v0 Complex_poly$)) (= (coeff$b (reflect_poly$ ?v0) zero$a) (coeff$b ?v0 (degree$b ?v0)))) :named a49)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= (coeff$b ?v0 zero$a) zero$)) (= (degree$b (reflect_poly$ ?v0)) (degree$b ?v0)))) :named a50)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (=> (not (= (coeff$ ?v0 zero$a) zero$c)) (= (degree$ (reflect_poly$a ?v0)) (degree$ ?v0)))) :named a51)) +(assert (! (forall ((?v0 Nat_poly$)) (=> (not (= (coeff$a ?v0 zero$a) zero$a)) (= (degree$a (reflect_poly$b ?v0)) (degree$a ?v0)))) :named a52)) +(assert (! (forall ((?v0 Complex_poly$)) (= (poly$ (reflect_poly$ ?v0) zero$) (coeff$b ?v0 (degree$b ?v0)))) :named a53)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (poly$a (reflect_poly$a ?v0) zero$c) (coeff$ ?v0 (degree$ ?v0)))) :named a54)) +(assert (! (forall ((?v0 Nat_poly$)) (= (poly$b (reflect_poly$b ?v0) zero$a) (coeff$a ?v0 (degree$a ?v0)))) :named a55)) +(assert (! (forall ((?v0 Complex_poly$)) (= (poly$ ?v0 zero$) (coeff$b ?v0 zero$a))) :named a56)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (poly$a ?v0 zero$c) (coeff$ ?v0 zero$a))) :named a57)) +(assert (! (forall ((?v0 Nat_poly$)) (= (poly$b ?v0 zero$a) (coeff$a ?v0 zero$a))) :named a58)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat_poly$) (?v2 Nat$)) (= (coeff$a (plus$b ?v0 ?v1) ?v2) (plus$a (coeff$a ?v0 ?v2) (coeff$a ?v1 ?v2)))) :named a59)) +(assert (! (forall ((?v0 Complex_poly$)) (= (forall ((?v1 Complex$)) (= (poly$ ?v0 ?v1) zero$)) (= ?v0 zero$c))) :named a60)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (forall ((?v1 Complex_poly$)) (= (poly$a ?v0 ?v1) zero$c)) (= ?v0 zero$b))) :named a61)) +(assert (! (forall ((?v0 Nat$)) (= (coeff$ zero$b ?v0) zero$c)) :named a62)) +(assert (! (forall ((?v0 Nat$)) (= (coeff$a zero$d ?v0) zero$a)) :named a63)) +(assert (! (forall ((?v0 Nat$)) (= (coeff$b zero$c ?v0) zero$)) :named a64)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (=> (not (= ?v0 zero$b)) (not (= (coeff$ ?v0 (degree$ ?v0)) zero$c)))) :named a65)) +(assert (! (forall ((?v0 Nat_poly$)) (=> (not (= ?v0 zero$d)) (not (= (coeff$a ?v0 (degree$a ?v0)) zero$a)))) :named a66)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= ?v0 zero$c)) (not (= (coeff$b ?v0 (degree$b ?v0)) zero$)))) :named a67)) +(assert (! (forall ((?v0 Complex_poly$)) (! (= (power$ ?v0 zero$a) one$a) :pattern ((power$ ?v0)))) :named a68)) +(assert (! (forall ((?v0 Nat$)) (! (= (power$c ?v0 zero$a) one$) :pattern ((power$c ?v0)))) :named a69)) +(assert (! (forall ((?v0 Nat$)) (= (power$d zero$ ?v0) (ite (= ?v0 zero$a) one$b zero$))) :named a70)) +(assert (! (forall ((?v0 Nat$)) (= (power$ zero$c ?v0) (ite (= ?v0 zero$a) one$a zero$c))) :named a71)) +(assert (! (forall ((?v0 Nat$)) (= (power$c zero$a ?v0) (ite (= ?v0 zero$a) one$ zero$a))) :named a72)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (degree$b (offset_poly$ ?v0 ?v1)) (degree$b ?v0))) :named a73)) +(assert (! (forall ((?v0 Complex_poly$)) (= (constant$ (poly$ ?v0)) (= (degree$b ?v0) zero$a))) :named a74)) +(assert (! (forall ((?v0 Complex$)) (= zero$ (poly$ zero$c ?v0))) :named a75)) +(assert (! (forall ((?v0 Complex_poly$)) (= zero$c (poly$a zero$b ?v0))) :named a76)) +(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex$)) (and (= (poly$ ?v0 ?v1) zero$) (not (= (poly$ zero$c ?v1) zero$)))) false)) :named a77)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (exists ((?v1 Complex_poly$)) (and (= (poly$a ?v0 ?v1) zero$c) (not (= (poly$a zero$b ?v1) zero$c)))) false)) :named a78)) +(assert (! (forall ((?v0 Nat_poly$)) (= (exists ((?v1 Nat$)) (and (= (poly$b ?v0 ?v1) zero$a) (not (= (poly$b zero$d ?v1) zero$a)))) false)) :named a79)) +(assert (! (= (exists ((?v0 Complex_poly$)) (not (= (poly$a zero$b ?v0) zero$c))) false) :named a80)) +(assert (! (= (exists ((?v0 Nat$)) (not (= (poly$b zero$d ?v0) zero$a))) false) :named a81)) +(assert (! (= (exists ((?v0 Complex$)) (not (= (poly$ zero$c ?v0) zero$))) false) :named a82)) +(assert (! (= (exists ((?v0 Complex_poly$)) (= (poly$a zero$b ?v0) zero$c)) true) :named a83)) +(assert (! (= (exists ((?v0 Nat$)) (= (poly$b zero$d ?v0) zero$a)) true) :named a84)) +(assert (! (= (exists ((?v0 Complex$)) (= (poly$ zero$c ?v0) zero$)) true) :named a85)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (=> (not (= ?v0 zero$)) (not (= (power$d ?v0 ?v1) zero$)))) :named a86)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (=> (not (= ?v0 zero$c)) (not (= (power$ ?v0 ?v1) zero$c)))) :named a87)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (not (= ?v0 zero$a)) (not (= (power$c ?v0 ?v1) zero$a)))) :named a88)) +(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a89)) +(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a90)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a91)) +(assert (! (forall ((?v0 Complex$)) (= (plus$ ?v0 zero$) ?v0)) :named a92)) +(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c ?v0 zero$c) ?v0)) :named a93)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a94)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= (plus$ ?v0 ?v1) ?v1) (= ?v0 zero$))) :named a95)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= (plus$c ?v0 ?v1) ?v1) (= ?v0 zero$c))) :named a96)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) ?v1) (= ?v0 zero$a))) :named a97)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= (plus$ ?v0 ?v1) ?v0) (= ?v1 zero$))) :named a98)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= (plus$c ?v0 ?v1) ?v0) (= ?v1 zero$c))) :named a99)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) ?v0) (= ?v1 zero$a))) :named a100)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= ?v0 (plus$ ?v1 ?v0)) (= ?v1 zero$))) :named a101)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= ?v0 (plus$c ?v1 ?v0)) (= ?v1 zero$c))) :named a102)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= ?v0 (plus$a ?v1 ?v0)) (= ?v1 zero$a))) :named a103)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= ?v0 (plus$ ?v0 ?v1)) (= ?v1 zero$))) :named a104)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= ?v0 (plus$c ?v0 ?v1)) (= ?v1 zero$c))) :named a105)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= ?v0 (plus$a ?v0 ?v1)) (= ?v1 zero$a))) :named a106)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) zero$a) (and (= ?v0 zero$a) (= ?v1 zero$a)))) :named a107)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= zero$a (plus$a ?v0 ?v1)) (and (= ?v0 zero$a) (= ?v1 zero$a)))) :named a108)) +(assert (! (forall ((?v0 Complex_poly$)) (! (= (power$ ?v0 zero$a) one$a) :pattern ((power$ ?v0)))) :named a109)) +(assert (! (forall ((?v0 Nat$)) (! (= (power$c ?v0 zero$a) one$) :pattern ((power$c ?v0)))) :named a110)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v2 ?v1)) (= ?v0 ?v2))) :named a111)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (= ?v1 ?v2))) :named a112)) +(assert (! (forall ((?v0 Complex_poly$)) (= (pcompose$ zero$c ?v0) zero$c)) :named a113)) +(assert (! (= (reflect_poly$ zero$c) zero$c) :named a114)) +(assert (! (= (degree$b zero$c) zero$a) :named a115)) +(assert (! (forall ((?v0 Complex_poly$)) (= (= (psize$ ?v0) zero$a) (= ?v0 zero$c))) :named a116)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (= (offset_poly$ ?v0 ?v1) zero$c) (= ?v0 zero$c))) :named a117)) +(assert (! (forall ((?v0 Complex$)) (= (offset_poly$ zero$c ?v0) zero$c)) :named a118)) +(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex$)) (not (= (poly$ ?v0 ?v1) zero$))) (not (= ?v0 zero$c)))) :named a119)) +(assert (! (forall ((?v0 Complex$)) (= (= zero$ ?v0) (= ?v0 zero$))) :named a120)) +(assert (! (forall ((?v0 Complex_poly$)) (= (= zero$c ?v0) (= ?v0 zero$c))) :named a121)) +(assert (! (forall ((?v0 Nat$)) (= (= zero$a ?v0) (= ?v0 zero$a))) :named a122)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (= (plus$a ?v0 ?v1) (plus$a ?v2 ?v1)) (= ?v0 ?v2))) :named a123)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (= (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (= ?v1 ?v2))) :named a124)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a ?v0 (plus$a ?v1 ?v2)) (plus$a ?v1 (plus$a ?v0 ?v2)))) :named a125)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (plus$a ?v0 ?v1) (plus$a ?v1 ?v0))) :named a126)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a ?v0 (plus$a ?v1 ?v2)))) :named a127)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$) (?v3 Nat$)) (= (plus$a (plus$a ?v0 ?v1) (plus$a ?v2 ?v3)) (plus$a (plus$a ?v0 ?v2) (plus$a ?v1 ?v3)))) :named a128)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a ?v0 (plus$a ?v1 ?v2)))) :named a129)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a ?v0 (plus$a ?v1 ?v2)) (plus$a ?v1 (plus$a ?v0 ?v2)))) :named a130)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a (plus$a ?v0 ?v2) ?v1))) :named a131)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (plus$a ?v0 ?v1) (plus$a ?v1 ?v0))) :named a132)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a ?v0 (plus$a ?v1 ?v2)) (plus$a (plus$a ?v0 ?v1) ?v2))) :named a133)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$) (?v3 Nat$)) (=> (and (= ?v0 ?v1) (= ?v2 ?v3)) (= (plus$a ?v0 ?v2) (plus$a ?v1 ?v3)))) :named a134)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a ?v0 (plus$a ?v1 ?v2)))) :named a135)) +(assert (! (forall ((?v0 Nat$)) (= (= one$ ?v0) (= ?v0 one$))) :named a136)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= ?v0 (plus$ ?v0 ?v1)) (= ?v1 zero$))) :named a137)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= ?v0 (plus$c ?v0 ?v1)) (= ?v1 zero$c))) :named a138)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= ?v0 (plus$a ?v0 ?v1)) (= ?v1 zero$a))) :named a139)) +(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a140)) +(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a141)) +(assert (! (forall ((?v0 Complex$)) (= (plus$ ?v0 zero$) ?v0)) :named a142)) +(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c ?v0 zero$c) ?v0)) :named a143)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a144)) +(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a145)) +(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a146)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a147)) +(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a148)) +(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a149)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a150)) +(assert (! (forall ((?v0 Complex$)) (= (plus$ ?v0 zero$) ?v0)) :named a151)) +(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c ?v0 zero$c) ?v0)) :named a152)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a153)) +(assert (! (forall ((?v0 Complex_poly$)) (= (power$ ?v0 one$) ?v0)) :named a154)) +(assert (! (forall ((?v0 Nat$)) (= (power$c ?v0 one$) ?v0)) :named a155)) +(assert (! (forall ((?v0 Nat$)) (= (poly_cutoff$ ?v0 one$a) (ite (= ?v0 zero$a) zero$c one$a))) :named a156)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a157)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) zero$a) (and (= ?v0 zero$a) (= ?v1 zero$a)))) :named a158)) +(assert (! (forall ((?v0 Nat$)) (= (poly_shift$ ?v0 one$a) (ite (= ?v0 zero$a) one$a zero$c))) :named a159)) +(assert (! (not (= zero$ one$b)) :named a160)) +(assert (! (not (= zero$c one$a)) :named a161)) +(assert (! (not (= zero$a one$)) :named a162)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (= (synthetic_div$ ?v0 ?v1) zero$c) (= (degree$b ?v0) zero$a))) :named a163)) +(assert (! (= (of_bool$ false) zero$) :named a164)) +(assert (! (= (of_bool$a false) zero$c) :named a165)) +(assert (! (= (of_bool$b false) zero$a) :named a166)) +(assert (! (= (of_bool$b true) one$) :named a167)) +(assert (! (forall ((?v0 Complex$)) (= (synthetic_div$ zero$c ?v0) zero$c)) :named a168)) +(assert (! (forall ((?v0 Nat$)) (= (poly_shift$ ?v0 zero$c) zero$c)) :named a169)) +(assert (! (forall ((?v0 Nat$)) (= (poly_cutoff$ ?v0 zero$c) zero$c)) :named a170)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (= ?v1 ?v2))) :named a171)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v2 ?v1)) (= ?v0 ?v2))) :named a172)) +(assert (! (forall ((?v0 Bool)) (! (= (of_bool$ ?v0) (ite ?v0 one$b zero$)) :pattern ((of_bool$ ?v0)))) :named a173)) +(assert (! (forall ((?v0 Bool)) (! (= (of_bool$a ?v0) (ite ?v0 one$a zero$c)) :pattern ((of_bool$a ?v0)))) :named a174)) +(assert (! (forall ((?v0 Bool)) (! (= (of_bool$b ?v0) (ite ?v0 one$ zero$a)) :pattern ((of_bool$b ?v0)))) :named a175)) +(assert (! (forall ((?v0 (-> Complex$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$ ?v1)) (and (=> ?v1 (?v0 one$b)) (=> (not ?v1) (?v0 zero$))))) :named a176)) +(assert (! (forall ((?v0 (-> Complex_poly$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$a ?v1)) (and (=> ?v1 (?v0 one$a)) (=> (not ?v1) (?v0 zero$c))))) :named a177)) +(assert (! (forall ((?v0 (-> Nat$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$b ?v1)) (and (=> ?v1 (?v0 one$)) (=> (not ?v1) (?v0 zero$a))))) :named a178)) +(assert (! (forall ((?v0 (-> Complex$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$ ?v1)) (not (or (and ?v1 (not (?v0 one$b))) (and (not ?v1) (not (?v0 zero$))))))) :named a179)) +(assert (! (forall ((?v0 (-> Complex_poly$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$a ?v1)) (not (or (and ?v1 (not (?v0 one$a))) (and (not ?v1) (not (?v0 zero$c))))))) :named a180)) +(assert (! (forall ((?v0 (-> Nat$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$b ?v1)) (not (or (and ?v1 (not (?v0 one$))) (and (not ?v1) (not (?v0 zero$a))))))) :named a181)) +(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a182)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (= (plus$a ?v0 ?v1) ?v0) (= ?v1 zero$a))) :named a183)) +(assert (! (forall ((?v0 Nat$)) (=> (and (=> (= ?v0 zero$a) false) (=> (not (= ?v0 zero$a)) false)) false)) :named a184)) +(assert (! (forall ((?v0 (-> Nat$ (-> Nat$ Bool))) (?v1 Nat$) (?v2 Nat$)) (=> (and (forall ((?v3 Nat$) (?v4 Nat$)) (= (?v0 ?v3 ?v4) (?v0 ?v4 ?v3))) (and (forall ((?v3 Nat$)) (?v0 ?v3 zero$a)) (forall ((?v3 Nat$) (?v4 Nat$)) (=> (?v0 ?v3 ?v4) (?v0 ?v3 (plus$a ?v3 ?v4)))))) (?v0 ?v1 ?v2))) :named a185)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (forall ((?v2 Complex$)) (=> (= (poly$ ?v0 ?v2) zero$) (= (poly$ ?v1 ?v2) zero$))) (or (dvd$ ?v0 (power$ ?v1 (degree$b ?v0))) (and (= ?v0 zero$c) (= ?v1 zero$c))))) :named a186)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Nat$)) (=> (and (forall ((?v3 Complex$)) (=> (= (poly$ ?v0 ?v3) zero$) (= (poly$ ?v1 ?v3) zero$))) (and (= (degree$b ?v0) ?v2) (not (= ?v2 zero$a)))) (dvd$ ?v0 (power$ ?v1 ?v2)))) :named a187)) +(assert (! (forall ((?v0 Complex_poly$)) (! (= (is_zero$ ?v0) (= ?v0 zero$c)) :pattern ((is_zero$ ?v0)))) :named a188)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (= (poly$ ?v0 ?v1) zero$) (or (= ?v0 zero$c) (not (= (order$ ?v1 ?v0) zero$a))))) :named a189)) +(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly$)) (= (= (poly$a ?v0 ?v1) zero$c) (or (= ?v0 zero$b) (not (= (order$a ?v1 ?v0) zero$a))))) :named a190)) +(assert (! (forall ((?v0 Complex$)) (dvd$a ?v0 zero$)) :named a191)) +(assert (! (forall ((?v0 Complex_poly$)) (dvd$ ?v0 zero$c)) :named a192)) +(assert (! (forall ((?v0 Nat$)) (dvd$b ?v0 zero$a)) :named a193)) +(assert (! (forall ((?v0 Complex$)) (= (dvd$a zero$ ?v0) (= ?v0 zero$))) :named a194)) +(assert (! (forall ((?v0 Complex_poly$)) (= (dvd$ zero$c ?v0) (= ?v0 zero$c))) :named a195)) +(assert (! (forall ((?v0 Nat$)) (= (dvd$b zero$a ?v0) (= ?v0 zero$a))) :named a196)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (dvd$ ?v0 (plus$c ?v0 ?v1)) (dvd$ ?v0 ?v1))) :named a197)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$b ?v0 (plus$a ?v0 ?v1)) (dvd$b ?v0 ?v1))) :named a198)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (dvd$ ?v0 (plus$c ?v1 ?v0)) (dvd$ ?v0 ?v1))) :named a199)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$b ?v0 (plus$a ?v1 ?v0)) (dvd$b ?v0 ?v1))) :named a200)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (not (= ?v0 zero$a)) (= (dvd$b (power$c ?v1 ?v0) (power$c ?v2 ?v0)) (dvd$b ?v1 ?v2)))) :named a201)) +(assert (! (forall ((?v0 Complex$)) (=> (dvd$a zero$ ?v0) (= ?v0 zero$))) :named a202)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (dvd$ zero$c ?v0) (= ?v0 zero$c))) :named a203)) +(assert (! (forall ((?v0 Nat$)) (=> (dvd$b zero$a ?v0) (= ?v0 zero$a))) :named a204)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (dvd$ ?v0 ?v1) (= (dvd$ ?v0 (plus$c ?v1 ?v2)) (dvd$ ?v0 ?v2)))) :named a205)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (dvd$b ?v0 ?v1) (= (dvd$b ?v0 (plus$a ?v1 ?v2)) (dvd$b ?v0 ?v2)))) :named a206)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (dvd$ ?v0 ?v1) (= (dvd$ ?v0 (plus$c ?v2 ?v1)) (dvd$ ?v0 ?v2)))) :named a207)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (dvd$b ?v0 ?v1) (= (dvd$b ?v0 (plus$a ?v2 ?v1)) (dvd$b ?v0 ?v2)))) :named a208)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (and (dvd$ ?v0 ?v1) (dvd$ ?v0 ?v2)) (dvd$ ?v0 (plus$c ?v1 ?v2)))) :named a209)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (and (dvd$b ?v0 ?v1) (dvd$b ?v0 ?v2)) (dvd$b ?v0 (plus$a ?v1 ?v2)))) :named a210)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (=> (and (dvd$ ?v0 ?v1) (dvd$ ?v1 one$a)) (dvd$ ?v0 one$a))) :named a211)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (and (dvd$b ?v0 ?v1) (dvd$b ?v1 one$)) (dvd$b ?v0 one$))) :named a212)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (=> (dvd$ ?v0 one$a) (dvd$ ?v0 ?v1))) :named a213)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (dvd$b ?v0 one$) (dvd$b ?v0 ?v1))) :named a214)) +(assert (! (forall ((?v0 Complex_poly$)) (dvd$ one$a ?v0)) :named a215)) +(assert (! (forall ((?v0 Nat$)) (dvd$b one$ ?v0)) :named a216)) +(assert (! (forall ((?v0 Complex_poly$)) (dvd$ ?v0 ?v0)) :named a217)) +(assert (! (forall ((?v0 Nat$)) (dvd$b ?v0 ?v0)) :named a218)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (and (dvd$ ?v0 ?v1) (dvd$ ?v1 ?v2)) (dvd$ ?v0 ?v2))) :named a219)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (and (dvd$b ?v0 ?v1) (dvd$b ?v1 ?v2)) (dvd$b ?v0 ?v2))) :named a220)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Nat$)) (=> (dvd$ ?v0 ?v1) (dvd$ (power$ ?v0 ?v2) (power$ ?v1 ?v2)))) :named a221)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (dvd$b ?v0 ?v1) (dvd$b (power$c ?v0 ?v2) (power$c ?v1 ?v2)))) :named a222)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (and (dvd$b (power$c ?v0 ?v1) (power$c ?v2 ?v1)) (not (= ?v1 zero$a))) (dvd$b ?v0 ?v2))) :named a223)) +(assert (! (not (dvd$ zero$c one$a)) :named a224)) +(assert (! (not (dvd$b zero$a one$)) :named a225)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (dvd$ (power$ ?v0 ?v1) one$a) (or (dvd$ ?v0 one$a) (= ?v1 zero$a)))) :named a226)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$b (power$c ?v0 ?v1) one$) (or (dvd$b ?v0 one$) (= ?v1 zero$a)))) :named a227)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (! (=> (not (= (poly$ ?v0 ?v1) zero$)) (= (order$ ?v1 ?v0) zero$a)) :pattern ((order$ ?v1 ?v0)))) :named a228)) +(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly$)) (! (=> (not (= (poly$a ?v0 ?v1) zero$c)) (= (order$a ?v1 ?v0) zero$a)) :pattern ((order$a ?v1 ?v0)))) :named a229)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= ?v0 zero$c)) (= (dvd$ ?v0 one$a) (= (degree$b ?v0) zero$a)))) :named a230)) +(assert (! (forall ((?v0 Complex_poly$)) (= (rsquarefree$ ?v0) (and (not (= ?v0 zero$c)) (forall ((?v1 Complex$)) (or (= (order$ ?v1 ?v0) zero$a) (= (order$ ?v1 ?v0) one$)))))) :named a231)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$) (?v2 Complex_poly$)) (=> (not (= ?v0 zero$c)) (= (exists ((?v3 Complex$)) (and (= (poly$ (pCons$ ?v1 ?v0) ?v3) zero$) (not (= (poly$ ?v2 ?v3) zero$)))) (not (dvd$ (pCons$ ?v1 ?v0) (power$ ?v2 (psize$ ?v0))))))) :named a232)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (! (= (dvd$a ?v0 ?v1) (=> (= ?v0 zero$) (= ?v1 zero$))) :pattern ((dvd$a ?v0 ?v1)))) :named a233)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (dvd$ ?v0 one$a) (= (monom$ (coeff$b ?v0 (degree$b ?v0)) zero$a) ?v0))) :named a234)) +(assert (! (forall ((?v0 Nat$)) (= (dvd$b ?v0 one$) (= ?v0 one$))) :named a235)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$) (?v2 Complex$) (?v3 Complex_poly$)) (= (= (pCons$ ?v0 ?v1) (pCons$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a236)) +(assert (! (= (pCons$ zero$ zero$c) zero$c) :named a237)) +(assert (! (= (pCons$a zero$c zero$b) zero$b) :named a238)) +(assert (! (= (pCons$b zero$a zero$d) zero$d) :named a239)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly_poly$)) (= (= (pCons$a ?v0 ?v1) zero$b) (and (= ?v0 zero$c) (= ?v1 zero$b)))) :named a240)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat_poly$)) (= (= (pCons$b ?v0 ?v1) zero$d) (and (= ?v0 zero$a) (= ?v1 zero$d)))) :named a241)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (= (pCons$ ?v0 ?v1) zero$c) (and (= ?v0 zero$) (= ?v1 zero$c)))) :named a242)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (coeff$b (pCons$ ?v0 ?v1) zero$a) ?v0)) :named a243)) +(assert (! (forall ((?v0 Nat$)) (= (monom$ zero$ ?v0) zero$c)) :named a244)) +(assert (! (forall ((?v0 Nat$)) (= (monom$a zero$c ?v0) zero$b)) :named a245)) +(assert (! (forall ((?v0 Nat$)) (= (monom$b zero$a ?v0) zero$d)) :named a246)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (= (monom$a ?v0 ?v1) zero$b) (= ?v0 zero$c))) :named a247)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (monom$b ?v0 ?v1) zero$d) (= ?v0 zero$a))) :named a248)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (= (monom$ ?v0 ?v1) zero$c) (= ?v0 zero$))) :named a249)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$b (monom$ ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$))) :named a250)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$ (monom$a ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$c))) :named a251)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$a (monom$b ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$a))) :named a252)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$) (?v2 Complex$) (?v3 Complex_poly$)) (= (plus$c (pCons$ ?v0 ?v1) (pCons$ ?v2 ?v3)) (pCons$ (plus$ ?v0 ?v2) (plus$c ?v1 ?v3)))) :named a253)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat_poly$) (?v2 Nat$) (?v3 Nat_poly$)) (= (plus$b (pCons$b ?v0 ?v1) (pCons$b ?v2 ?v3)) (pCons$b (plus$a ?v0 ?v2) (plus$b ?v1 ?v3)))) :named a254)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (coeff$b (monom$ ?v0 ?v1) (degree$b (monom$ ?v0 ?v1))) ?v0)) :named a255)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (=> (not (= ?v0 zero$)) (= (order$ zero$ (monom$ ?v0 ?v1)) ?v1))) :named a256)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (=> (not (= ?v0 zero$c)) (= (order$a zero$c (monom$a ?v0 ?v1)) ?v1))) :named a257)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (pcompose$ (pCons$ ?v0 zero$c) ?v1) (pCons$ ?v0 zero$c))) :named a258)) +(assert (! (forall ((?v0 Complex$)) (= (reflect_poly$ (pCons$ ?v0 zero$c)) (pCons$ ?v0 zero$c))) :named a259)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$) (?v2 Complex$)) (= (synthetic_div$ (pCons$ ?v0 ?v1) ?v2) (pCons$ (poly$ ?v1 ?v2) (synthetic_div$ ?v1 ?v2)))) :named a260)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (=> (= ?v0 zero$c) (= (coeff$b (pCons$ ?v1 ?v0) (degree$b (pCons$ ?v1 ?v0))) ?v1))) :named a261)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (=> (not (= ?v0 zero$c)) (= (coeff$b (pCons$ ?v1 ?v0) (degree$b (pCons$ ?v1 ?v0))) (coeff$b ?v0 (degree$b ?v0))))) :named a262)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (dvd$c (pCons$a ?v0 zero$b) (pCons$a ?v1 zero$b)) (dvd$ ?v0 ?v1))) :named a263)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$d (pCons$b ?v0 zero$d) (pCons$b ?v1 zero$d)) (dvd$b ?v0 ?v1))) :named a264)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (dvd$ (pCons$ ?v0 zero$c) (pCons$ ?v1 zero$c)) (dvd$a ?v0 ?v1))) :named a265)) +(assert (! (= (= (pCons$b one$ zero$d) one$c) true) :named a266)) +(assert (! (= (= (pCons$ one$b zero$c) one$a) true) :named a267)) +(assert (! (= (= one$c (pCons$b one$ zero$d)) true) :named a268)) +(assert (! (= (= one$a (pCons$ one$b zero$c)) true) :named a269)) +(assert (! (= (monom$b one$ zero$a) one$c) :named a270)) +(assert (! (forall ((?v0 Complex_poly$)) (= (pcompose$ ?v0 (pCons$ zero$ (pCons$ one$b zero$c))) ?v0)) :named a271)) +(assert (! (forall ((?v0 Complex_poly_poly$)) (= (pcompose$a ?v0 (pCons$a zero$c (pCons$a one$a zero$b))) ?v0)) :named a272)) +(assert (! (forall ((?v0 Nat_poly$)) (= (pcompose$b ?v0 (pCons$b zero$a (pCons$b one$ zero$d))) ?v0)) :named a273)) +(assert (! (forall ((?v0 Nat$)) (=> (dvd$b zero$a ?v0) (= ?v0 zero$a))) :named a274)) +(assert (! (forall ((?v0 Nat$)) (= (not (= ?v0 zero$a)) (and (dvd$b ?v0 zero$a) (not (= ?v0 zero$a))))) :named a275)) +(assert (! (forall ((?v0 Nat$)) (! (= (dvd$b zero$a ?v0) (= ?v0 zero$a)) :pattern ((dvd$b zero$a ?v0)))) :named a276)) +(assert (! (forall ((?v0 Nat$)) (not (and (dvd$b zero$a ?v0) (not (= zero$a ?v0))))) :named a277)) +(assert (! (forall ((?v0 Nat$)) (dvd$b ?v0 zero$a)) :named a278)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Complex_poly$)) (= (= (monom$a ?v0 ?v1) (pCons$a ?v2 zero$b)) (and (= ?v0 ?v2) (or (= ?v0 zero$c) (= ?v1 zero$a))))) :named a279)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (monom$b ?v0 ?v1) (pCons$b ?v2 zero$d)) (and (= ?v0 ?v2) (or (= ?v0 zero$a) (= ?v1 zero$a))))) :named a280)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Complex$)) (= (= (monom$ ?v0 ?v1) (pCons$ ?v2 zero$c)) (and (= ?v0 ?v2) (or (= ?v0 zero$) (= ?v1 zero$a))))) :named a281)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (forall ((?v1 Complex$) (?v2 Complex_poly$)) (=> (= ?v0 (pCons$ ?v1 ?v2)) false)) false)) :named a282)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (forall ((?v1 Complex$) (?v2 Complex_poly$)) (=> (= ?v0 (pCons$ ?v1 ?v2)) false)) false)) :named a283)) +(assert (! (forall ((?v0 (-> Complex_poly$ (-> Complex_poly$ Bool))) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (and (?v0 zero$c zero$c) (forall ((?v3 Complex$) (?v4 Complex_poly$) (?v5 Complex$) (?v6 Complex_poly$)) (=> (?v0 ?v4 ?v6) (?v0 (pCons$ ?v3 ?v4) (pCons$ ?v5 ?v6))))) (?v0 ?v1 ?v2))) :named a284)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Complex$) (?v3 Nat$)) (= (= (monom$ ?v0 ?v1) (monom$ ?v2 ?v3)) (and (= ?v0 ?v2) (or (= ?v0 zero$) (= ?v1 ?v3))))) :named a285)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Complex_poly$) (?v3 Nat$)) (= (= (monom$a ?v0 ?v1) (monom$a ?v2 ?v3)) (and (= ?v0 ?v2) (or (= ?v0 zero$c) (= ?v1 ?v3))))) :named a286)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$) (?v3 Nat$)) (= (= (monom$b ?v0 ?v1) (monom$b ?v2 ?v3)) (and (= ?v0 ?v2) (or (= ?v0 zero$a) (= ?v1 ?v3))))) :named a287)) +(assert (! (forall ((?v0 Complex$)) (! (= (monom$ ?v0 zero$a) (pCons$ ?v0 zero$c)) :pattern ((monom$ ?v0)))) :named a288)) +(assert (! (forall ((?v0 (-> Complex_poly_poly$ Bool)) (?v1 Complex_poly_poly$)) (=> (and (?v0 zero$b) (forall ((?v2 Complex_poly$) (?v3 Complex_poly_poly$)) (=> (and (or (not (= ?v2 zero$c)) (not (= ?v3 zero$b))) (?v0 ?v3)) (?v0 (pCons$a ?v2 ?v3))))) (?v0 ?v1))) :named a289)) +(assert (! (forall ((?v0 (-> Nat_poly$ Bool)) (?v1 Nat_poly$)) (=> (and (?v0 zero$d) (forall ((?v2 Nat$) (?v3 Nat_poly$)) (=> (and (or (not (= ?v2 zero$a)) (not (= ?v3 zero$d))) (?v0 ?v3)) (?v0 (pCons$b ?v2 ?v3))))) (?v0 ?v1))) :named a290)) +(assert (! (forall ((?v0 (-> Complex_poly$ Bool)) (?v1 Complex_poly$)) (=> (and (?v0 zero$c) (forall ((?v2 Complex$) (?v3 Complex_poly$)) (=> (and (or (not (= ?v2 zero$)) (not (= ?v3 zero$c))) (?v0 ?v3)) (?v0 (pCons$ ?v2 ?v3))))) (?v0 ?v1))) :named a291)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (=> (= (poly$ ?v0 ?v1) zero$) (= (poly$ (pCons$ zero$ ?v0) ?v1) zero$))) :named a292)) +(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly$)) (=> (= (poly$a ?v0 ?v1) zero$c) (= (poly$a (pCons$a zero$c ?v0) ?v1) zero$c))) :named a293)) +(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$)) (=> (= (poly$b ?v0 ?v1) zero$a) (= (poly$b (pCons$b zero$a ?v0) ?v1) zero$a))) :named a294)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (=> (not (= ?v0 zero$)) (= (degree$b (monom$ ?v0 ?v1)) ?v1))) :named a295)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (=> (not (= ?v0 zero$c)) (= (degree$ (monom$a ?v0 ?v1)) ?v1))) :named a296)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (not (= ?v0 zero$a)) (= (degree$a (monom$b ?v0 ?v1)) ?v1))) :named a297)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$b (monom$ ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$))) :named a298)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$ (monom$a ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$c))) :named a299)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$a (monom$b ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$a))) :named a300)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (=> (dvd$ ?v0 ?v1) (dvd$ ?v0 (pCons$ zero$ ?v1)))) :named a301)) +(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly_poly$)) (=> (dvd$c ?v0 ?v1) (dvd$c ?v0 (pCons$a zero$c ?v1)))) :named a302)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (poly$ (pCons$ (poly$ zero$c ?v0) zero$c) ?v1) (poly$ zero$c ?v1))) :named a303)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= ?v0 (poly$ (pCons$ ?v0 zero$c) ?v1))) :named a304)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$b (monom$b ?v0 ?v1) (monom$b ?v2 ?v1)) (monom$b (plus$a ?v0 ?v2) ?v1))) :named a305)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (offset_poly$ (pCons$ ?v0 zero$c) ?v1) (pCons$ ?v0 zero$c))) :named a306)) +(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex_poly$)) (= (poly$a (pCons$a ?v0 zero$b) ?v1) zero$c)) (= ?v0 zero$c))) :named a307)) +(assert (! (forall ((?v0 Nat$)) (= (exists ((?v1 Nat$)) (= (poly$b (pCons$b ?v0 zero$d) ?v1) zero$a)) (= ?v0 zero$a))) :named a308)) +(assert (! (forall ((?v0 Complex$)) (= (exists ((?v1 Complex$)) (= (poly$ (pCons$ ?v0 zero$c) ?v1) zero$)) (= ?v0 zero$))) :named a309)) +(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex_poly$)) (not (= (poly$a (pCons$a ?v0 zero$b) ?v1) zero$c))) (not (= ?v0 zero$c)))) :named a310)) +(assert (! (forall ((?v0 Nat$)) (= (exists ((?v1 Nat$)) (not (= (poly$b (pCons$b ?v0 zero$d) ?v1) zero$a))) (not (= ?v0 zero$a)))) :named a311)) +(assert (! (forall ((?v0 Complex$)) (= (exists ((?v1 Complex$)) (not (= (poly$ (pCons$ ?v0 zero$c) ?v1) zero$))) (not (= ?v0 zero$)))) :named a312)) +(assert (! (forall ((?v0 Complex$)) (= (poly$ (pCons$ zero$ zero$c) ?v0) (poly$ zero$c ?v0))) :named a313)) +(assert (! (forall ((?v0 Complex_poly$)) (= (poly$a (pCons$a zero$c zero$b) ?v0) (poly$a zero$b ?v0))) :named a314)) +(assert (! (forall ((?v0 Complex$)) (= (degree$b (pCons$ ?v0 zero$c)) zero$a)) :named a315)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (and (= (degree$b ?v0) zero$a) (forall ((?v1 Complex$)) (=> (= ?v0 (pCons$ ?v1 zero$c)) false))) false)) :named a316)) +(assert (! (= (pCons$b one$ zero$d) one$c) :named a317)) +(assert (! (= (pCons$ one$b zero$c) one$a) :named a318)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (monom$b ?v0 ?v1) one$c) (and (= ?v0 one$) (= ?v1 zero$a)))) :named a319)) +(assert (! (forall ((?v0 Complex$)) (= ?v0 (poly$ (pCons$ zero$ (pCons$ one$b zero$c)) ?v0))) :named a320)) +(assert (! (forall ((?v0 Complex_poly$)) (= ?v0 (poly$a (pCons$a zero$c (pCons$a one$a zero$b)) ?v0))) :named a321)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (not (exists ((?v1 Complex$) (?v2 Complex_poly$)) (and (not (= ?v1 zero$)) (and (= ?v2 zero$c) (= ?v0 (pCons$ ?v1 ?v2)))))) (exists ((?v1 Complex$)) (= (poly$ ?v0 ?v1) zero$)))) :named a322)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$) (?v2 Complex$)) (=> (not (= ?v0 zero$c)) (exists ((?v3 Complex$)) (= (poly$ (pCons$ ?v1 (pCons$ ?v2 ?v0)) ?v3) zero$)))) :named a323)) +(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly_poly$)) (= (dvd$c (pCons$a ?v0 zero$b) ?v1) (forall ((?v2 Nat$)) (dvd$ ?v0 (coeff$ ?v1 ?v2))))) :named a324)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat_poly$)) (= (dvd$d (pCons$b ?v0 zero$d) ?v1) (forall ((?v2 Nat$)) (dvd$b ?v0 (coeff$a ?v1 ?v2))))) :named a325)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (dvd$ (pCons$ ?v0 zero$c) ?v1) (forall ((?v2 Nat$)) (dvd$a ?v0 (coeff$b ?v1 ?v2))))) :named a326)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (degree$a (power$b (pCons$b ?v0 (pCons$b one$ zero$d)) ?v1)) ?v1)) :named a327)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (degree$b (power$ (pCons$ ?v0 (pCons$ one$b zero$c)) ?v1)) ?v1)) :named a328)) +(assert (! (forall ((?v0 Complex_poly$)) (= (pcompose$ ?v0 zero$c) (pCons$ (coeff$b ?v0 zero$a) zero$c))) :named a329)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (coeff$a (power$b (pCons$b ?v0 (pCons$b one$ zero$d)) ?v1) ?v1) one$)) :named a330)) +(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (coeff$b (power$ (pCons$ ?v0 (pCons$ one$b zero$c)) ?v1) ?v1) one$b)) :named a331)) +(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (dvd$ (pCons$ ?v0 ?v1) one$a) (and (= ?v1 zero$c) (not (= ?v0 zero$))))) :named a332)) +(assert (! (forall ((?v0 Complex$)) (=> (not (= ?v0 zero$)) (dvd$ (pCons$ ?v0 zero$c) one$a))) :named a333)) +(assert (! (forall ((?v0 Complex_poly$)) (=> (and (dvd$ ?v0 one$a) (forall ((?v1 Complex$)) (=> (and (= ?v0 (monom$ ?v1 zero$a)) (not (= ?v1 zero$))) false))) false)) :named a334)) +(assert (! (forall ((?v0 Complex$)) (=> (not (= ?v0 zero$)) (dvd$ (monom$ ?v0 zero$a) one$a))) :named a335)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (times$ ?v0 ?v1) (times$ ?v2 ?v1)) (or (= ?v0 ?v2) (= ?v1 zero$a)))) :named a336)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (times$ ?v0 ?v1) (times$ ?v0 ?v2)) (or (= ?v1 ?v2) (= ?v0 zero$a)))) :named a337)) +(assert (! (forall ((?v0 Nat$)) (! (= (times$ ?v0 zero$a) zero$a) :pattern ((times$ ?v0)))) :named a338)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (times$ ?v0 ?v1) zero$a) (or (= ?v0 zero$a) (= ?v1 zero$a)))) :named a339)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (suc$ ?v0) (suc$ ?v1)) (= ?v0 ?v1))) :named a340)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (suc$ ?v0) (suc$ ?v1)) (= ?v0 ?v1))) :named a341)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (times$ ?v0 ?v1) one$) (and (= ?v0 one$) (= ?v1 one$)))) :named a342)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= one$ (times$ ?v0 ?v1)) (and (= ?v0 one$) (= ?v1 one$)))) :named a343)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (times$ ?v0 ?v1) (suc$ zero$a)) (and (= ?v0 (suc$ zero$a)) (= ?v1 (suc$ zero$a))))) :named a344)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (suc$ zero$a) (times$ ?v0 ?v1)) (and (= ?v0 (suc$ zero$a)) (= ?v1 (suc$ zero$a))))) :named a345)) +(assert (! (forall ((?v0 Nat$)) (! (= (power$c (suc$ zero$a) ?v0) (suc$ zero$a)) :pattern ((power$c (suc$ zero$a) ?v0)))) :named a346)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (power$c ?v0 ?v1) (suc$ zero$a)) (or (= ?v1 zero$a) (= ?v0 (suc$ zero$a))))) :named a347)) +(assert (! (forall ((?v0 Nat$)) (less_eq$ zero$a ?v0)) :named a348)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (less_eq$ (suc$ ?v0) (suc$ ?v1)) (less_eq$ ?v0 ?v1))) :named a349)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (plus$a ?v0 (suc$ ?v1)) (suc$ (plus$a ?v0 ?v1)))) :named a350)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (! (= (times$ ?v0 (suc$ ?v1)) (plus$a ?v0 (times$ ?v0 ?v1))) :pattern ((times$ ?v0 (suc$ ?v1))))) :named a351)) +(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (less_eq$ (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (less_eq$ ?v1 ?v2))) :named a352)) +(check-sat) diff --git a/test/regress/regress1/ho/ho-exponential-model.smt2 b/test/regress/regress1/ho/ho-exponential-model.smt2 new file mode 100644 index 000000000..3f0011828 --- /dev/null +++ b/test/regress/regress1/ho/ho-exponential-model.smt2 @@ -0,0 +1,40 @@ +; COMMAND-LINE: --uf-ho +; EXPECT: sat +(set-logic UFLIA) +(set-info :status sat) +(declare-fun f1 (Int Int Int Int) Int) +(declare-fun f2 (Int Int Int) Int) +(declare-fun f3 (Int Int) Int) +(declare-fun f4 (Int) Int) +(declare-fun f5 (Int Int Int) Int) +(declare-fun f6 (Int Int) Int) +(declare-fun f7 (Int) Int) + + +(assert (= (f1 0) (f1 1))) +(assert (= (f1 1) f2)) + +(assert (= (f2 0) (f2 1))) +(assert (= (f2 1) f3)) + +(assert (= (f3 0) (f3 1))) +(assert (= (f3 1) f4)) + +(assert (= (f4 0) (f4 1))) +(assert (= (f4 1) 2)) + + +(assert (= (f1 3) (f1 4))) +(assert (= (f1 4) f5)) + +(assert (= (f5 3) (f5 4))) +(assert (= (f5 4) f6)) + +(assert (= (f6 3) (f6 4))) +(assert (= (f6 4) f7)) + +(assert (= (f7 3) (f7 4))) +(assert (= (f7 4) 5)) + +; this benchmark has a concise model representation for f1 if we use curried (tree-like) models for UF +(check-sat) diff --git a/test/regress/regress1/ho/ho-matching-enum-2.smt2 b/test/regress/regress1/ho/ho-matching-enum-2.smt2 new file mode 100644 index 000000000..9581e4c4f --- /dev/null +++ b/test/regress/regress1/ho/ho-matching-enum-2.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --uf-ho +; EXPECT: unsat +(set-logic ALL) +(set-info :status unsat) + +(declare-sort U 0) + +(declare-fun p (Int) Bool) +(declare-fun q (Int) Bool) +(declare-fun k (Int Int) Int) + +(assert (q (k 0 1))) +(assert (not (p (k 0 0)))) + +(assert (forall ((f (-> Int Int Int)) (y Int) (z Int)) (or (p (f y z)) (not (q (f z y)))))) + +(check-sat) +(exit) diff --git a/test/regress/regress1/ho/ho-std-fmf.smt2 b/test/regress/regress1/ho/ho-std-fmf.smt2 new file mode 100644 index 000000000..61d82d00c --- /dev/null +++ b/test/regress/regress1/ho/ho-std-fmf.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --uf-ho --finite-model-find +; EXPECT: sat +(set-logic UF) +(set-info :status sat) +(declare-sort U 0) +(declare-fun P (U U) Bool) +(declare-fun Q (U U) Bool) +(declare-fun R (U U) Bool) +(declare-fun a () U) +(declare-fun b () U) + +; can solve this using standard MBQI model for P = \ xy true +(assert (forall ((x U) (y U)) (or (P x y) (Q x y)))) +(assert (forall ((x U) (y U)) (or (P x y) (R x y)))) + +(assert (not (= a b))) +(assert (= (Q a) (R b))) +(check-sat) diff --git a/test/regress/regress1/ho/hoa0102.smt2 b/test/regress/regress1/ho/hoa0102.smt2 new file mode 100644 index 000000000..6be063783 --- /dev/null +++ b/test/regress/regress1/ho/hoa0102.smt2 @@ -0,0 +1,606 @@ +; COMMAND-LINE: --uf-ho --full-saturate-quant +; EXPECT: unsat +(set-logic ALL) +(set-info :status unsat) +(declare-sort Com$ 0) +(declare-sort Glb$ 0) +(declare-sort Loc$ 0) +(declare-sort Nat$ 0) +(declare-sort Pname$ 0) +(declare-sort State$ 0) +(declare-sort Vname$ 0) +(declare-sort Com_set$ 0) +(declare-sort Pname_set$ 0) +(declare-sort Com_option$ 0) +(declare-sort Pname_option$ 0) +(declare-sort State_triple$ 0) +(declare-sort Com_option_set$ 0) +(declare-sort Pname_option_set$ 0) +(declare-sort State_triple_set$ 0) +(declare-sort Com_option_option$ 0) +(declare-sort State_triple_option$ 0) +(declare-sort Com_option_option_set$ 0) +(declare-sort State_triple_option_set$ 0) +(declare-sort State_triple_option_option$ 0) +(declare-sort State_triple_option_option_set$ 0) +(declare-fun c$ () Com$) +(declare-fun s$ () State$) +(declare-fun z$ () State$) +(declare-fun uu$ (Com_set$ Com$) Bool) +(declare-fun wt$ (Com$) Bool) +(declare-fun arg$ () Loc$) +(declare-fun ass$ (Vname$ (-> State$ Nat$)) Com$) +(declare-fun bot$ () Pname_set$) +(declare-fun dom$ ((-> State_triple$ State_triple_option$)) State_triple_set$) +(declare-fun glb$ (Glb$) Vname$) +(declare-fun loc$ (Loc$) Vname$) +(declare-fun mgt$ (Com$) State_triple$) +(declare-fun ran$ ((-> State_triple$ Com_option$)) Com_set$) +(declare-fun res$ () Loc$) +(declare-fun suc$ (Nat$) Nat$) +(declare-fun sup$ (State_triple_set$ State_triple_set$) State_triple_set$) +(declare-fun the$ (Com_option$) Com$) +(declare-fun uua$ (State_triple_set$ State_triple$) Bool) +(declare-fun uub$ (Pname_set$ Pname$) Bool) +(declare-fun uuc$ ((-> State$ (-> State$ Bool)) State$ Vname$ State$ State$) Bool) +(declare-fun uud$ ((-> State$ (-> State$ Bool)) State$ (-> State$ Nat$) State$ State$) Bool) +(declare-fun uue$ (Com$) Com_option$) +(declare-fun uuf$ (State_triple$) Bool) +(declare-fun uug$ (Com$) Bool) +(declare-fun uuh$ (State_triple$) Bool) +(declare-fun uui$ (Com$) Bool) +(declare-fun uuj$ ((-> State$ (-> State$ Bool)) Loc$ State$ State$ State$) Bool) +(declare-fun uuk$ ((-> State$ (-> State$ Bool)) Loc$ State$ (-> State$ Nat$) State$ State$) Bool) +(declare-fun uul$ ((-> State$ (-> State$ Bool)) (-> State$ Bool) State$ State$) Bool) +(declare-fun uum$ (Bool (-> State$ (-> State$ Bool)) State$ State$) Bool) +(declare-fun uun$ (State$ State$ State$) Bool) +(declare-fun uuo$ ((-> State$ (-> State$ Bool)) State$ State$) (-> State$ Bool)) +(declare-fun uup$ ((-> State$ (-> State$ Bool)) Vname$ (-> State$ Nat$) State$ State$) Bool) +(declare-fun uuq$ (State$ State$) Bool) +(declare-fun uur$ ((-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$) +(declare-fun uus$ ((-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$) +(declare-fun uut$ (Bool) Bool) +(declare-fun uuu$ ((-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ Com$) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$) +(declare-fun uuv$ ((-> Pname$ Com$) (-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$) +(declare-fun uuw$ (Com$ State$ State$) Bool) +(declare-fun uux$ (Nat$ (-> State$ (-> State$ Bool)) Com$ (-> State$ (-> State$ Bool))) Bool) +(declare-fun uuy$ (State_triple$) Com_option$) +(declare-fun uuz$ (Pname$) Com_option$) +(declare-fun uva$ (State_triple$) State_triple_option$) +(declare-fun uvb$ (Com$) State_triple_option$) +(declare-fun uvc$ (Pname$) State_triple_option$) +(declare-fun uvd$ (State_triple_option$) State_triple_option$) +(declare-fun uve$ (State_triple_option$) Com_option$) +(declare-fun uvf$ (Com_option$) State_triple_option$) +(declare-fun uvg$ (Com_option$) Com_option$) +(declare-fun uvh$ ((-> State_triple$ Com_option$) State_triple$) Bool) +(declare-fun uvi$ ((-> Pname$ State_triple_option$) Pname$) Bool) +(declare-fun uvj$ ((-> Pname$ Com_option$) Pname$) Bool) +(declare-fun uvk$ ((-> Com$ Com$) Com$) Com_option$) +(declare-fun bind$ (State_triple_option$ (-> State_triple$ Com_option$)) Com_option$) +(declare-fun body$ (Pname$) Com_option$) +(declare-fun bot$a () State_triple_option_set$) +(declare-fun bot$b () Com_option_set$) +(declare-fun bot$c () Com_set$) +(declare-fun bot$d () State_triple_set$) +(declare-fun bot$e () Pname_option_set$) +(declare-fun bot$f () State_triple_option_option_set$) +(declare-fun bot$g () Com_option_option_set$) +(declare-fun call$ (Vname$ Pname$ (-> State$ Nat$)) Com$) +(declare-fun comp$ ((-> Bool Bool) (-> State$ Bool)) (-> State$ Bool)) +(declare-fun cond$ ((-> State$ Bool) Com$ Com$) Com$) +(declare-fun dom$a ((-> Com$ State_triple_option$)) Com_set$) +(declare-fun dom$b ((-> Com$ Com_option$)) Com_set$) +(declare-fun dom$c ((-> Pname$ State_triple_option$)) Pname_set$) +(declare-fun dom$d ((-> State_triple_option$ State_triple_option$)) State_triple_option_set$) +(declare-fun dom$e ((-> State_triple_option$ Com_option$)) State_triple_option_set$) +(declare-fun dom$f ((-> Com_option$ State_triple_option$)) Com_option_set$) +(declare-fun dom$g ((-> Com_option$ Com_option$)) Com_option_set$) +(declare-fun dom$h ((-> Pname$ Com_option$)) Pname_set$) +(declare-fun dom$i ((-> State_triple$ Com_option$)) State_triple_set$) +(declare-fun none$ () Com_option$) +(declare-fun plus$ (Nat$ Nat$) Nat$) +(declare-fun ran$a ((-> Pname$ Com_option$)) Com_set$) +(declare-fun semi$ (Com$ Com$) Com$) +(declare-fun size$ (State_triple$) Nat$) +(declare-fun skip$ () Com$) +(declare-fun some$ (Com$) Com_option$) +(declare-fun the$a (State_triple_option$) State_triple$) +(declare-fun the$b (Pname_option$) Pname$) +(declare-fun zero$ () Nat$) +(declare-fun bind$a (Com_option$ (-> Com$ State_triple_option$)) State_triple_option$) +(declare-fun bind$b (State_triple_option$ (-> State_triple$ State_triple_option$)) State_triple_option$) +(declare-fun bind$c (Com_option$ (-> Com$ Com_option$)) Com_option$) +(declare-fun body$a (Pname$) Com$) +(declare-fun evalc$ (Com$ State$ State$) Bool) +(declare-fun evaln$ (Com$ State$ Nat$ State$) Bool) +(declare-fun image$ ((-> Pname$ State_triple$) Pname_set$) State_triple_set$) +(declare-fun local$ (Loc$ (-> State$ Nat$) Com$) Com$) +(declare-fun minus$ (Com_set$ Com_set$) Com_set$) +(declare-fun none$a () State_triple_option$) +(declare-fun none$b () Pname_option$) +(declare-fun none$c () State_triple_option_option$) +(declare-fun none$d () Com_option_option$) +(declare-fun size$a (State_triple_option$) Nat$) +(declare-fun size$b (Com_option$) Nat$) +(declare-fun size$c (Vname$) Nat$) +(declare-fun size$d (Com$) Nat$) +(declare-fun some$a (State_triple$) State_triple_option$) +(declare-fun these$ (Pname_option_set$) Pname_set$) +(declare-fun while$ ((-> State$ Bool) Com$) Com$) +(declare-fun finite$ (Pname_set$) Bool) +(declare-fun insert$ (State_triple$ State_triple_set$) State_triple_set$) +(declare-fun map_le$ ((-> State_triple$ Com_option$) (-> State_triple$ Com_option$)) Bool) +(declare-fun member$ (State_triple$ State_triple_set$) Bool) +(declare-fun minus$a (State_triple_option_set$ State_triple_option_set$) State_triple_option_set$) +(declare-fun minus$b (Com_option_set$ Com_option_set$) Com_option_set$) +(declare-fun minus$c (State_triple_set$ State_triple_set$) State_triple_set$) +(declare-fun minus$d (Pname_set$ Pname_set$) Pname_set$) +(declare-fun these$a (State_triple_option_option_set$) State_triple_option_set$) +(declare-fun these$b (Com_option_option_set$) Com_option_set$) +(declare-fun these$c (Com_option_set$) Com_set$) +(declare-fun these$d (State_triple_option_set$) State_triple_set$) +(declare-fun triple$ ((-> State$ (-> State$ Bool)) Com$ (-> State$ (-> State$ Bool))) State_triple$) +(declare-fun uminus$ (State_triple_set$) State_triple_set$) +(declare-fun update$ (State$ Vname$ Nat$) State$) +(declare-fun collect$ ((-> Com$ Bool)) Com_set$) +(declare-fun fun_upd$ ((-> State_triple$ Com_option$) State_triple$ Com_option$) (-> State_triple$ Com_option$)) +(declare-fun getlocs$ (State$) (-> Loc$ Nat$)) +(declare-fun insert$a (Com$ Com_set$) Com_set$) +(declare-fun insert$b (Pname$ Pname_set$) Pname_set$) +(declare-fun insert$c (State_triple_option$ State_triple_option_set$) State_triple_option_set$) +(declare-fun insert$d (Com_option$ Com_option_set$) Com_option_set$) +(declare-fun insert$e (Pname_option$ Pname_option_set$) Pname_option_set$) +(declare-fun insert$f (State_triple_option_option$ State_triple_option_option_set$) State_triple_option_option_set$) +(declare-fun insert$g (Com_option_option$ Com_option_option_set$) Com_option_option_set$) +(declare-fun map_le$a ((-> Pname$ Com_option$) (-> Pname$ Com_option$)) Bool) +(declare-fun member$a (Pname$ Pname_set$) Bool) +(declare-fun member$b (Com$ Com_set$) Bool) +(declare-fun member$c (State_triple_option$ State_triple_option_set$) Bool) +(declare-fun member$d (Com_option$ Com_option_set$) Bool) +(declare-fun newlocs$ () (-> Loc$ Nat$)) +(declare-fun setlocs$ (State$ (-> Loc$ Nat$)) State$) +(declare-fun collect$a ((-> State_triple$ Bool)) State_triple_set$) +(declare-fun collect$b ((-> Pname$ Bool)) Pname_set$) +(declare-fun fun_upd$a ((-> Pname$ Com_option$) Pname$ Com_option$) (-> Pname$ Com_option$)) +(declare-fun fun_upd$b ((-> State_triple$ State_triple_option$) State_triple$ State_triple_option$) (-> State_triple$ State_triple_option$)) +(declare-fun fun_upd$c ((-> Com$ State_triple_option$) Com$ State_triple_option$) (-> Com$ State_triple_option$)) +(declare-fun fun_upd$d ((-> Com$ Com_option$) Com$ Com_option$) (-> Com$ Com_option$)) +(declare-fun fun_upd$e ((-> Pname$ State_triple_option$) Pname$ State_triple_option$) (-> Pname$ State_triple_option$)) +(declare-fun fun_upd$f ((-> State_triple_option$ State_triple_option$) State_triple_option$ State_triple_option$) (-> State_triple_option$ State_triple_option$)) +(declare-fun fun_upd$g ((-> State_triple_option$ Com_option$) State_triple_option$ Com_option$) (-> State_triple_option$ Com_option$)) +(declare-fun fun_upd$h ((-> Com_option$ State_triple_option$) Com_option$ State_triple_option$) (-> Com_option$ State_triple_option$)) +(declare-fun fun_upd$i ((-> Com_option$ Com_option$) Com_option$ Com_option$) (-> Com_option$ Com_option$)) +(declare-fun peek_and$ ((-> State$ (-> State$ Bool)) (-> State$ Bool)) (-> State$ (-> State$ Bool))) +(declare-fun size_com$ (Com$) Nat$) +(declare-fun wT_bodies$ () Bool) +(declare-fun map_option$ ((-> Com$ Com$) Com_option$) Com_option$) +(declare-fun set_option$ (Pname_option$) Pname_set$) +(declare-fun size_vname$ (Vname$) Nat$) +(declare-fun case_option$ (Bool (-> Com$ Bool) Com_option$) Bool) +(declare-fun case_triple$ ((-> (-> State$ (-> State$ Bool)) (-> Com$ (-> (-> State$ (-> State$ Bool)) Bool))) State_triple$) Bool) +(declare-fun map_option$a ((-> State_triple$ Com$) State_triple_option$) Com_option$) +(declare-fun map_option$b ((-> Com$ State_triple$) Com_option$) State_triple_option$) +(declare-fun map_option$c ((-> State_triple$ State_triple$) State_triple_option$) State_triple_option$) +(declare-fun set_option$a (State_triple_option$) State_triple_set$) +(declare-fun set_option$b (Com_option$) Com_set$) +(declare-fun set_option$c (State_triple_option_option$) State_triple_option_set$) +(declare-fun set_option$d (Com_option_option$) Com_option_set$) +(declare-fun size_option$ ((-> State_triple$ Nat$)) (-> State_triple_option$ Nat$)) +(declare-fun size_triple$ ((-> State$ Nat$) State_triple$) Nat$) +(declare-fun case_option$a (Bool (-> State_triple$ Bool) State_triple_option$) Bool) +(declare-fun case_option$b (Com_option$ (-> Com$ Com_option$) Com_option$) Com_option$) +(declare-fun hoare_derivs$ (State_triple_set$ State_triple_set$) Bool) +(declare-fun hoare_valids$ (State_triple_set$ State_triple_set$) Bool) +(declare-fun restrict_map$ ((-> Com$ Com_option$) Com_set$) (-> Com$ Com_option$)) +(declare-fun size_option$a ((-> Com$ Nat$)) (-> Com_option$ Nat$)) +(declare-fun triple_valid$ (Nat$ State_triple$) Bool) +(declare-fun restrict_map$a ((-> Com$ State_triple_option$) Com_set$) (-> Com$ State_triple_option$)) +(declare-fun restrict_map$b ((-> State_triple_option$ Com_option$) State_triple_option_set$) (-> State_triple_option$ Com_option$)) +(declare-fun restrict_map$c ((-> State_triple_option$ State_triple_option$) State_triple_option_set$) (-> State_triple_option$ State_triple_option$)) +(declare-fun restrict_map$d ((-> Com_option$ Com_option$) Com_option_set$) (-> Com_option$ Com_option$)) +(declare-fun restrict_map$e ((-> Com_option$ State_triple_option$) Com_option_set$) (-> Com_option$ State_triple_option$)) +(declare-fun restrict_map$f ((-> State_triple$ State_triple_option$) State_triple_set$) (-> State_triple$ State_triple_option$)) +(declare-fun restrict_map$g ((-> Pname$ Com_option$) Pname_set$) (-> Pname$ Com_option$)) +(declare-fun restrict_map$h ((-> Pname$ State_triple_option$) Pname_set$) (-> Pname$ State_triple_option$)) +(declare-fun restrict_map$i ((-> State_triple$ Com_option$) State_triple_set$) (-> State_triple$ Com_option$)) +(declare-fun state_not_singleton$ () Bool) +(assert (! (forall ((?v0 Bool)) (! (= (uut$ ?v0) (not ?v0)) :pattern ((uut$ ?v0)))) :named a0)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$)) (! (= (uua$ ?v0 ?v1) (member$ ?v1 ?v0)) :pattern ((uua$ ?v0 ?v1)))) :named a1)) +(assert (! (forall ((?v0 Pname_set$) (?v1 Pname$)) (! (= (uub$ ?v0 ?v1) (member$a ?v1 ?v0)) :pattern ((uub$ ?v0 ?v1)))) :named a2)) +(assert (! (forall ((?v0 Com_set$) (?v1 Com$)) (! (= (uu$ ?v0 ?v1) (member$b ?v1 ?v0)) :pattern ((uu$ ?v0 ?v1)))) :named a3)) +(assert (! (forall ((?v0 State$) (?v1 State$)) (! (= (uuq$ ?v0 ?v1) (= ?v0 ?v1)) :pattern ((uuq$ ?v0 ?v1)))) :named a4)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (! (= (uvh$ ?v0 ?v1) (not (= (?v0 ?v1) none$))) :pattern ((uvh$ ?v0 ?v1)))) :named a5)) +(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$)) (! (= (uvi$ ?v0 ?v1) (not (= (?v0 ?v1) none$a))) :pattern ((uvi$ ?v0 ?v1)))) :named a6)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (! (= (uvj$ ?v0 ?v1) (not (= (?v0 ?v1) none$))) :pattern ((uvj$ ?v0 ?v1)))) :named a7)) +(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com$)) (! (= (uvk$ ?v0 ?v1) (some$ (?v0 ?v1))) :pattern ((uvk$ ?v0 ?v1)))) :named a8)) +(assert (! (forall ((?v0 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 Pname$)) (! (= (uus$ ?v0 ?v1 ?v2) (triple$ (?v0 ?v2) (the$ (body$ ?v2)) (?v1 ?v2))) :pattern ((uus$ ?v0 ?v1 ?v2)))) :named a9)) +(assert (! (forall ((?v0 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 Pname$)) (! (= (uur$ ?v0 ?v1 ?v2) (triple$ (?v0 ?v2) (body$a ?v2) (?v1 ?v2))) :pattern ((uur$ ?v0 ?v1 ?v2)))) :named a10)) +(assert (! (forall ((?v0 State$) (?v1 State$) (?v2 State$)) (! (= (uun$ ?v0 ?v1 ?v2) (= ?v2 ?v0)) :pattern ((uun$ ?v0 ?v1 ?v2)))) :named a11)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State$) (?v2 State$)) (! (= (uuo$ ?v0 ?v1 ?v2) (?v0 ?v1)) :pattern ((uuo$ ?v0 ?v1 ?v2)))) :named a12)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$)) (! (= (uuw$ ?v0 ?v1 ?v2) (forall ((?v3 State$)) (=> (evalc$ ?v0 ?v2 ?v3) (= ?v1 ?v3)))) :pattern ((uuw$ ?v0 ?v1 ?v2)))) :named a13)) +(assert (! (forall ((?v0 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v1 (-> Pname$ Com$)) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname$)) (! (= (uuu$ ?v0 ?v1 ?v2 ?v3) (triple$ (?v0 ?v3) (?v1 ?v3) (?v2 ?v3))) :pattern ((uuu$ ?v0 ?v1 ?v2 ?v3)))) :named a14)) +(assert (! (forall ((?v0 (-> Pname$ Com$)) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname$)) (! (= (uuv$ ?v0 ?v1 ?v2 ?v3) (triple$ (?v1 ?v3) (?v0 ?v3) (?v2 ?v3))) :pattern ((uuv$ ?v0 ?v1 ?v2 ?v3)))) :named a15)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 (-> State$ Bool)) (?v2 State$) (?v3 State$)) (! (= (uul$ ?v0 ?v1 ?v2 ?v3) (and (?v0 ?v2 ?v3) (not (?v1 ?v3)))) :pattern ((uul$ ?v0 ?v1 ?v2 ?v3)))) :named a16)) +(assert (! (forall ((?v0 Bool) (?v1 (-> State$ (-> State$ Bool))) (?v2 State$) (?v3 State$)) (! (= (uum$ ?v0 ?v1 ?v2 ?v3) (and (?v1 ?v2 ?v3) ?v0)) :pattern ((uum$ ?v0 ?v1 ?v2 ?v3)))) :named a17)) +(assert (! (forall ((?v0 Nat$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (! (= (uux$ ?v0 ?v1 ?v2 ?v3) (forall ((?v4 State$) (?v5 State$)) (=> (?v1 ?v4 ?v5) (forall ((?v6 State$)) (=> (evaln$ ?v2 ?v5 ?v0 ?v6) (?v3 ?v4 ?v6)))))) :pattern ((uux$ ?v0 ?v1 ?v2 ?v3)))) :named a18)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State$) (?v2 Vname$) (?v3 State$) (?v4 State$)) (! (= (uuc$ ?v0 ?v1 ?v2 ?v3 ?v4) (?v0 ?v3 (update$ (setlocs$ ?v4 (getlocs$ ?v1)) ?v2 (getlocs$ ?v4 res$)))) :pattern ((uuc$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a19)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Loc$) (?v2 State$) (?v3 State$) (?v4 State$)) (! (= (uuj$ ?v0 ?v1 ?v2 ?v3 ?v4) (?v0 ?v3 (update$ ?v4 (loc$ ?v1) (getlocs$ ?v2 ?v1)))) :pattern ((uuj$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a20)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Vname$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 State$)) (! (= (uup$ ?v0 ?v1 ?v2 ?v3 ?v4) (?v0 ?v3 (update$ ?v4 ?v1 (?v2 ?v4)))) :pattern ((uup$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a21)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 State$)) (! (= (uud$ ?v0 ?v1 ?v2 ?v3 ?v4) (and (= ?v1 ?v4) (?v0 ?v3 (update$ (setlocs$ ?v4 newlocs$) (loc$ arg$) (?v2 ?v4))))) :pattern ((uud$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a22)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Loc$) (?v2 State$) (?v3 (-> State$ Nat$)) (?v4 State$) (?v5 State$)) (! (= (uuk$ ?v0 ?v1 ?v2 ?v3 ?v4 ?v5) (and (= ?v2 ?v5) (?v0 ?v4 (update$ ?v5 (loc$ ?v1) (?v3 ?v5))))) :pattern ((uuk$ ?v0 ?v1 ?v2 ?v3 ?v4 ?v5)))) :named a23)) +(assert (! (forall ((?v0 State_triple$)) (! (= (uva$ ?v0) none$a) :pattern ((uva$ ?v0)))) :named a24)) +(assert (! (forall ((?v0 State_triple$)) (! (= (uuy$ ?v0) none$) :pattern ((uuy$ ?v0)))) :named a25)) +(assert (! (forall ((?v0 State_triple_option$)) (! (= (uvd$ ?v0) none$a) :pattern ((uvd$ ?v0)))) :named a26)) +(assert (! (forall ((?v0 State_triple_option$)) (! (= (uve$ ?v0) none$) :pattern ((uve$ ?v0)))) :named a27)) +(assert (! (forall ((?v0 Com_option$)) (! (= (uvf$ ?v0) none$a) :pattern ((uvf$ ?v0)))) :named a28)) +(assert (! (forall ((?v0 Com_option$)) (! (= (uvg$ ?v0) none$) :pattern ((uvg$ ?v0)))) :named a29)) +(assert (! (forall ((?v0 Pname$)) (! (= (uvc$ ?v0) none$a) :pattern ((uvc$ ?v0)))) :named a30)) +(assert (! (forall ((?v0 Pname$)) (! (= (uuz$ ?v0) none$) :pattern ((uuz$ ?v0)))) :named a31)) +(assert (! (forall ((?v0 Com$)) (! (= (uvb$ ?v0) none$a) :pattern ((uvb$ ?v0)))) :named a32)) +(assert (! (forall ((?v0 Com$)) (! (= (uue$ ?v0) none$) :pattern ((uue$ ?v0)))) :named a33)) +(assert (! (forall ((?v0 State_triple$)) (! (= (uuh$ ?v0) false) :pattern ((uuh$ ?v0)))) :named a34)) +(assert (! (forall ((?v0 Com$)) (! (= (uui$ ?v0) false) :pattern ((uui$ ?v0)))) :named a35)) +(assert (! (forall ((?v0 State_triple$)) (! (= (uuf$ ?v0) true) :pattern ((uuf$ ?v0)))) :named a36)) +(assert (! (forall ((?v0 Com$)) (! (= (uug$ ?v0) true) :pattern ((uug$ ?v0)))) :named a37)) +(assert (! (not false) :named a38)) +(assert (! (forall ((?v0 State$)) (= ?v0 s$)) :named a39)) +(assert (! (forall ((?v0 State$)) (not (evalc$ c$ z$ ?v0))) :named a40)) +(assert (! (forall ((?v0 State$)) (=> (forall ((?v1 State$)) (= ?v1 ?v0)) false)) :named a41)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$) (?v3 State$)) (=> (and (evalc$ ?v0 ?v1 ?v2) (evalc$ ?v0 ?v1 ?v3)) (= ?v3 ?v2))) :named a42)) +(assert (! (=> state_not_singleton$ (forall ((?v0 State$)) (=> (forall ((?v1 State$)) (= ?v1 ?v0)) false))) :named a43)) +(assert (! (= state_not_singleton$ (exists ((?v0 State$) (?v1 State$)) (not (= ?v0 ?v1)))) :named a44)) +(assert (! (forall ((?v0 State$) (?v1 State$)) (=> (and (evalc$ skip$ ?v0 ?v1) (=> (= ?v1 ?v0) false)) false)) :named a45)) +(assert (! (forall ((?v0 State$)) (evalc$ skip$ ?v0 ?v0)) :named a46)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 State$) (?v3 State$)) (=> (and (evalc$ (semi$ ?v0 ?v1) ?v2 ?v3) (forall ((?v4 State$)) (=> (and (evalc$ ?v0 ?v2 ?v4) (evalc$ ?v1 ?v4 ?v3)) false))) false)) :named a47)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$) (?v3 Com$) (?v4 State$)) (=> (and (evalc$ ?v0 ?v1 ?v2) (evalc$ ?v3 ?v2 ?v4)) (evalc$ (semi$ ?v0 ?v3) ?v1 ?v4))) :named a48)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 State$) (?v4 State$)) (=> (and (evalc$ (cond$ ?v0 ?v1 ?v2) ?v3 ?v4) (and (=> (and (?v0 ?v3) (evalc$ ?v1 ?v3 ?v4)) false) (=> (and (not (?v0 ?v3)) (evalc$ ?v2 ?v3 ?v4)) false))) false)) :named a49)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 State$) (?v4 Com$)) (=> (and (?v0 ?v1) (evalc$ ?v2 ?v1 ?v3)) (evalc$ (cond$ ?v0 ?v2 ?v4) ?v1 ?v3))) :named a50)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 State$) (?v4 Com$)) (=> (and (not (?v0 ?v1)) (evalc$ ?v2 ?v1 ?v3)) (evalc$ (cond$ ?v0 ?v4 ?v2) ?v1 ?v3))) :named a51)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 State$) (?v4 State$)) (=> (and (?v0 ?v1) (and (evalc$ ?v2 ?v1 ?v3) (evalc$ (while$ ?v0 ?v2) ?v3 ?v4))) (evalc$ (while$ ?v0 ?v2) ?v1 ?v4))) :named a52)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$)) (=> (not (?v0 ?v1)) (evalc$ (while$ ?v0 ?v2) ?v1 ?v1))) :named a53)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 State$) (?v3 State$)) (=> (and (evalc$ (while$ ?v0 ?v1) ?v2 ?v3) (and (=> (and (= ?v3 ?v2) (not (?v0 ?v2))) false) (forall ((?v4 State$)) (=> (and (?v0 ?v2) (and (evalc$ ?v1 ?v2 ?v4) (evalc$ (while$ ?v0 ?v1) ?v4 ?v3))) false)))) false)) :named a54)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 Com$) (?v3 Com$)) (= (= (semi$ ?v0 ?v1) (semi$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a55)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$) (?v5 Com$)) (= (= (cond$ ?v0 ?v1 ?v2) (cond$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a56)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 (-> State$ Bool)) (?v3 Com$)) (= (= (while$ ?v0 ?v1) (while$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a57)) +(assert (! (forall ((?v0 Com$) (?v1 Com$)) (not (= skip$ (semi$ ?v0 ?v1)))) :named a58)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (not (= skip$ (cond$ ?v0 ?v1 ?v2)))) :named a59)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 Com$)) (not (= (semi$ ?v0 ?v1) (cond$ ?v2 ?v3 ?v4)))) :named a60)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (not (= skip$ (while$ ?v0 ?v1)))) :named a61)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 (-> State$ Bool)) (?v3 Com$)) (not (= (semi$ ?v0 ?v1) (while$ ?v2 ?v3)))) :named a62)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$)) (not (= (cond$ ?v0 ?v1 ?v2) (while$ ?v3 ?v4)))) :named a63)) +(assert (! (forall ((?v0 State$) (?v1 Nat$) (?v2 State$)) (=> (and (evaln$ skip$ ?v0 ?v1 ?v2) (=> (= ?v2 ?v0) false)) false)) :named a64)) +(assert (! (forall ((?v0 State$) (?v1 Nat$)) (evaln$ skip$ ?v0 ?v1 ?v0)) :named a65)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$) (?v4 Com$) (?v5 State$) (?v6 Nat$) (?v7 State$)) (=> (and (evaln$ ?v0 ?v1 ?v2 ?v3) (evaln$ ?v4 ?v5 ?v6 ?v7)) (exists ((?v8 Nat$)) (and (evaln$ ?v0 ?v1 ?v8 ?v3) (evaln$ ?v4 ?v5 ?v8 ?v7))))) :named a66)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$)) (= (evalc$ ?v0 ?v1 ?v2) (exists ((?v3 Nat$)) (evaln$ ?v0 ?v1 ?v3 ?v2)))) :named a67)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$)) (=> (evalc$ ?v0 ?v1 ?v2) (exists ((?v3 Nat$)) (evaln$ ?v0 ?v1 ?v3 ?v2)))) :named a68)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (evaln$ ?v0 ?v1 ?v2 ?v3) (evalc$ ?v0 ?v1 ?v3))) :named a69)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 State$) (?v3 Nat$) (?v4 State$)) (=> (and (evaln$ (while$ ?v0 ?v1) ?v2 ?v3 ?v4) (and (=> (and (= ?v4 ?v2) (not (?v0 ?v2))) false) (forall ((?v5 State$)) (=> (and (?v0 ?v2) (and (evaln$ ?v1 ?v2 ?v3 ?v5) (evaln$ (while$ ?v0 ?v1) ?v5 ?v3 ?v4))) false)))) false)) :named a70)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$)) (=> (not (?v0 ?v1)) (evaln$ (while$ ?v0 ?v2) ?v1 ?v3 ?v1))) :named a71)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$) (?v4 State$) (?v5 State$)) (=> (and (?v0 ?v1) (and (evaln$ ?v2 ?v1 ?v3 ?v4) (evaln$ (while$ ?v0 ?v2) ?v4 ?v3 ?v5))) (evaln$ (while$ ?v0 ?v2) ?v1 ?v3 ?v5))) :named a72)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$) (?v4 State$) (?v5 Com$)) (=> (and (not (?v0 ?v1)) (evaln$ ?v2 ?v1 ?v3 ?v4)) (evaln$ (cond$ ?v0 ?v5 ?v2) ?v1 ?v3 ?v4))) :named a73)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$) (?v4 State$) (?v5 Com$)) (=> (and (?v0 ?v1) (evaln$ ?v2 ?v1 ?v3 ?v4)) (evaln$ (cond$ ?v0 ?v2 ?v5) ?v1 ?v3 ?v4))) :named a74)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 State$) (?v4 Nat$) (?v5 State$)) (=> (and (evaln$ (cond$ ?v0 ?v1 ?v2) ?v3 ?v4 ?v5) (and (=> (and (?v0 ?v3) (evaln$ ?v1 ?v3 ?v4 ?v5)) false) (=> (and (not (?v0 ?v3)) (evaln$ ?v2 ?v3 ?v4 ?v5)) false))) false)) :named a75)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$) (?v4 Com$) (?v5 State$)) (=> (and (evaln$ ?v0 ?v1 ?v2 ?v3) (evaln$ ?v4 ?v3 ?v2 ?v5)) (evaln$ (semi$ ?v0 ?v4) ?v1 ?v2 ?v5))) :named a76)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 State$) (?v3 Nat$) (?v4 State$)) (=> (and (evaln$ (semi$ ?v0 ?v1) ?v2 ?v3 ?v4) (forall ((?v5 State$)) (=> (and (evaln$ ?v0 ?v2 ?v3 ?v5) (evaln$ ?v1 ?v5 ?v3 ?v4)) false))) false)) :named a77)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (not (= skip$ (ass$ ?v0 ?v1)))) :named a78)) +(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Bool))) (= (member$b ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a79)) +(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Bool))) (= (member$ ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a80)) +(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Bool))) (= (member$a ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a81)) +(assert (! (forall ((?v0 Com_set$)) (= (collect$ (uu$ ?v0)) ?v0)) :named a82)) +(assert (! (forall ((?v0 State_triple_set$)) (= (collect$a (uua$ ?v0)) ?v0)) :named a83)) +(assert (! (forall ((?v0 Pname_set$)) (= (collect$b (uub$ ?v0)) ?v0)) :named a84)) +(assert (! (forall ((?v0 (-> Pname$ Bool)) (?v1 (-> Pname$ Bool))) (=> (forall ((?v2 Pname$)) (= (?v0 ?v2) (?v1 ?v2))) (= (collect$b ?v0) (collect$b ?v1)))) :named a85)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (not (= skip$ (local$ ?v0 ?v1 ?v2)))) :named a86)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Vname$) (?v3 (-> State$ Nat$))) (= (= (ass$ ?v0 ?v1) (ass$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a87)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Loc$) (?v4 (-> State$ Nat$)) (?v5 Com$)) (= (= (local$ ?v0 ?v1 ?v2) (local$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a88)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Loc$) (?v3 (-> State$ Nat$)) (?v4 Com$)) (not (= (ass$ ?v0 ?v1) (local$ ?v2 ?v3 ?v4)))) :named a89)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$)) (not (= (local$ ?v0 ?v1 ?v2) (while$ ?v3 ?v4)))) :named a90)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 (-> State$ Bool)) (?v3 Com$)) (not (= (ass$ ?v0 ?v1) (while$ ?v2 ?v3)))) :named a91)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$) (?v5 Com$)) (not (= (local$ ?v0 ?v1 ?v2) (cond$ ?v3 ?v4 ?v5)))) :named a92)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 Com$)) (not (= (ass$ ?v0 ?v1) (cond$ ?v2 ?v3 ?v4)))) :named a93)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Com$) (?v4 Com$)) (not (= (local$ ?v0 ?v1 ?v2) (semi$ ?v3 ?v4)))) :named a94)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Com$)) (not (= (ass$ ?v0 ?v1) (semi$ ?v2 ?v3)))) :named a95)) +(assert (! (forall ((?v0 Com$)) (=> (and (=> (= ?v0 skip$) false) (and (forall ((?v1 Vname$) (?v2 (-> State$ Nat$))) (=> (= ?v0 (ass$ ?v1 ?v2)) false)) (and (forall ((?v1 Loc$) (?v2 (-> State$ Nat$)) (?v3 Com$)) (=> (= ?v0 (local$ ?v1 ?v2 ?v3)) false)) (and (forall ((?v1 Com$) (?v2 Com$)) (=> (= ?v0 (semi$ ?v1 ?v2)) false)) (and (forall ((?v1 (-> State$ Bool)) (?v2 Com$) (?v3 Com$)) (=> (= ?v0 (cond$ ?v1 ?v2 ?v3)) false)) (and (forall ((?v1 (-> State$ Bool)) (?v2 Com$)) (=> (= ?v0 (while$ ?v1 ?v2)) false)) (and (forall ((?v1 Pname$)) (=> (= ?v0 (body$a ?v1)) false)) (forall ((?v1 Vname$) (?v2 Pname$) (?v3 (-> State$ Nat$))) (=> (= ?v0 (call$ ?v1 ?v2 ?v3)) false))))))))) false)) :named a96)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$)) (evalc$ (ass$ ?v0 ?v1) ?v2 (update$ ?v2 ?v0 (?v1 ?v2)))) :named a97)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$) (?v3 State$)) (=> (and (evalc$ (ass$ ?v0 ?v1) ?v2 ?v3) (=> (= ?v3 (update$ ?v2 ?v0 (?v1 ?v2))) false)) false)) :named a98)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$) (?v3 Nat$)) (evaln$ (ass$ ?v0 ?v1) ?v2 ?v3 (update$ ?v2 ?v0 (?v1 ?v2)))) :named a99)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$) (?v3 Nat$) (?v4 State$)) (=> (and (evaln$ (ass$ ?v0 ?v1) ?v2 ?v3 ?v4) (=> (= ?v4 (update$ ?v2 ?v0 (?v1 ?v2))) false)) false)) :named a100)) +(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (not (= skip$ (call$ ?v0 ?v1 ?v2)))) :named a101)) +(assert (! (forall ((?v0 Pname$) (?v1 Pname$)) (= (= (body$a ?v0) (body$a ?v1)) (= ?v0 ?v1))) :named a102)) +(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$)) (?v3 Vname$) (?v4 Pname$) (?v5 (-> State$ Nat$))) (= (= (call$ ?v0 ?v1 ?v2) (call$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a103)) +(assert (! (forall ((?v0 Pname$) (?v1 Vname$) (?v2 Pname$) (?v3 (-> State$ Nat$))) (not (= (body$a ?v0) (call$ ?v1 ?v2 ?v3)))) :named a104)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Pname$)) (not (= (while$ ?v0 ?v1) (body$a ?v2)))) :named a105)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 Pname$)) (not (= (cond$ ?v0 ?v1 ?v2) (body$a ?v3)))) :named a106)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 Pname$)) (not (= (semi$ ?v0 ?v1) (body$a ?v2)))) :named a107)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Pname$)) (not (= (local$ ?v0 ?v1 ?v2) (body$a ?v3)))) :named a108)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Pname$)) (not (= (ass$ ?v0 ?v1) (body$a ?v2)))) :named a109)) +(assert (! (forall ((?v0 Pname$)) (not (= skip$ (body$a ?v0)))) :named a110)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Vname$) (?v3 Pname$) (?v4 (-> State$ Nat$))) (not (= (while$ ?v0 ?v1) (call$ ?v2 ?v3 ?v4)))) :named a111)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 Vname$) (?v4 Pname$) (?v5 (-> State$ Nat$))) (not (= (cond$ ?v0 ?v1 ?v2) (call$ ?v3 ?v4 ?v5)))) :named a112)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 Vname$) (?v3 Pname$) (?v4 (-> State$ Nat$))) (not (= (semi$ ?v0 ?v1) (call$ ?v2 ?v3 ?v4)))) :named a113)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Vname$) (?v4 Pname$) (?v5 (-> State$ Nat$))) (not (= (local$ ?v0 ?v1 ?v2) (call$ ?v3 ?v4 ?v5)))) :named a114)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Vname$) (?v3 Pname$) (?v4 (-> State$ Nat$))) (not (= (ass$ ?v0 ?v1) (call$ ?v2 ?v3 ?v4)))) :named a115)) +(assert (! (forall ((?v0 Com$)) (= (wt$ ?v0) (or (= ?v0 skip$) (or (exists ((?v1 Vname$) (?v2 (-> State$ Nat$))) (= ?v0 (ass$ ?v1 ?v2))) (or (exists ((?v1 Com$) (?v2 Loc$) (?v3 (-> State$ Nat$))) (and (= ?v0 (local$ ?v2 ?v3 ?v1)) (wt$ ?v1))) (or (exists ((?v1 Com$) (?v2 Com$)) (and (= ?v0 (semi$ ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2)))) (or (exists ((?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool))) (and (= ?v0 (cond$ ?v3 ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2)))) (or (exists ((?v1 Com$) (?v2 (-> State$ Bool))) (and (= ?v0 (while$ ?v2 ?v1)) (wt$ ?v1))) (or (exists ((?v1 Pname$)) (and (= ?v0 (body$a ?v1)) (not (= (body$ ?v1) none$)))) (exists ((?v1 Pname$) (?v2 Vname$) (?v3 (-> State$ Nat$))) (and (= ?v0 (call$ ?v2 ?v1 ?v3)) (wt$ (body$a ?v1))))))))))))) :named a116)) +(assert (! (forall ((?v0 Com$)) (=> (and (wt$ ?v0) (and (=> (= ?v0 skip$) false) (and (forall ((?v1 Vname$) (?v2 (-> State$ Nat$))) (=> (= ?v0 (ass$ ?v1 ?v2)) false)) (and (forall ((?v1 Com$) (?v2 Loc$) (?v3 (-> State$ Nat$))) (=> (and (= ?v0 (local$ ?v2 ?v3 ?v1)) (wt$ ?v1)) false)) (and (forall ((?v1 Com$) (?v2 Com$)) (=> (and (= ?v0 (semi$ ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2))) false)) (and (forall ((?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool))) (=> (and (= ?v0 (cond$ ?v3 ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2))) false)) (and (forall ((?v1 Com$) (?v2 (-> State$ Bool))) (=> (and (= ?v0 (while$ ?v2 ?v1)) (wt$ ?v1)) false)) (and (forall ((?v1 Pname$)) (=> (and (= ?v0 (body$a ?v1)) (not (= (body$ ?v1) none$))) false)) (forall ((?v1 Pname$) (?v2 Vname$) (?v3 (-> State$ Nat$))) (=> (and (= ?v0 (call$ ?v2 ?v1 ?v3)) (wt$ (body$a ?v1))) false)))))))))) false)) :named a117)) +(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (=> (and (wt$ (call$ ?v0 ?v1 ?v2)) (=> (wt$ (body$a ?v1)) false)) false)) :named a118)) +(assert (! (forall ((?v0 Pname$) (?v1 Vname$) (?v2 (-> State$ Nat$))) (=> (wt$ (body$a ?v0)) (wt$ (call$ ?v1 ?v0 ?v2)))) :named a119)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 State$) (?v4 State$)) (=> (and (evalc$ (local$ ?v0 ?v1 ?v2) ?v3 ?v4) (forall ((?v5 State$)) (=> (and (= ?v4 (update$ ?v5 (loc$ ?v0) (getlocs$ ?v3 ?v0))) (evalc$ ?v2 (update$ ?v3 (loc$ ?v0) (?v1 ?v3)) ?v5)) false))) false)) :named a120)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Loc$) (?v3 (-> State$ Nat$)) (?v4 State$)) (=> (evalc$ ?v0 (update$ ?v1 (loc$ ?v2) (?v3 ?v1)) ?v4) (evalc$ (local$ ?v2 ?v3 ?v0) ?v1 (update$ ?v4 (loc$ ?v2) (getlocs$ ?v1 ?v2))))) :named a121)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Loc$) (?v3 (-> State$ Nat$)) (?v4 Nat$) (?v5 State$)) (=> (evaln$ ?v0 (update$ ?v1 (loc$ ?v2) (?v3 ?v1)) ?v4 ?v5) (evaln$ (local$ ?v2 ?v3 ?v0) ?v1 ?v4 (update$ ?v5 (loc$ ?v2) (getlocs$ ?v1 ?v2))))) :named a122)) +(assert (! (forall ((?v0 Loc$) (?v1 Loc$)) (= (= (loc$ ?v0) (loc$ ?v1)) (= ?v0 ?v1))) :named a123)) +(assert (! (forall ((?v0 Pname$)) (=> (not (= (body$ ?v0) none$)) (wt$ (body$a ?v0)))) :named a124)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (=> (and (wt$ (while$ ?v0 ?v1)) (=> (wt$ ?v1) false)) false)) :named a125)) +(assert (! (forall ((?v0 Com$) (?v1 (-> State$ Bool))) (=> (wt$ ?v0) (wt$ (while$ ?v1 ?v0)))) :named a126)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (=> (and (wt$ (cond$ ?v0 ?v1 ?v2)) (=> (and (wt$ ?v1) (wt$ ?v2)) false)) false)) :named a127)) +(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 (-> State$ Bool))) (=> (and (wt$ ?v0) (wt$ ?v1)) (wt$ (cond$ ?v2 ?v0 ?v1)))) :named a128)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (wt$ (ass$ ?v0 ?v1))) :named a129)) +(assert (! (forall ((?v0 Com$) (?v1 Loc$) (?v2 (-> State$ Nat$))) (=> (wt$ ?v0) (wt$ (local$ ?v1 ?v2 ?v0)))) :named a130)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (=> (and (wt$ (ass$ ?v0 ?v1)) false) false)) :named a131)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (=> (and (wt$ (local$ ?v0 ?v1 ?v2)) (=> (wt$ ?v2) false)) false)) :named a132)) +(assert (! (forall ((?v0 Com$) (?v1 Com$)) (=> (and (wt$ (semi$ ?v0 ?v1)) (=> (and (wt$ ?v0) (wt$ ?v1)) false)) false)) :named a133)) +(assert (! (forall ((?v0 Com$) (?v1 Com$)) (=> (and (wt$ ?v0) (wt$ ?v1)) (wt$ (semi$ ?v0 ?v1)))) :named a134)) +(assert (! (=> (and (wt$ skip$) false) false) :named a135)) +(assert (! (wt$ skip$) :named a136)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 State$) (?v4 Nat$) (?v5 State$)) (=> (and (evaln$ (local$ ?v0 ?v1 ?v2) ?v3 ?v4 ?v5) (forall ((?v6 State$)) (=> (and (= ?v5 (update$ ?v6 (loc$ ?v0) (getlocs$ ?v3 ?v0))) (evaln$ ?v2 (update$ ?v3 (loc$ ?v0) (?v1 ?v3)) ?v4 ?v6)) false))) false)) :named a137)) +(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 State$)) (=> (evalc$ (the$ (body$ ?v0)) ?v1 ?v2) (evalc$ (body$a ?v0) ?v1 ?v2))) :named a138)) +(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 State$)) (=> (and (evalc$ (body$a ?v0) ?v1 ?v2) (=> (evalc$ (the$ (body$ ?v0)) ?v1 ?v2) false)) false)) :named a139)) +(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 Vname$)) (=> (evalc$ (body$a ?v0) (update$ (setlocs$ ?v1 newlocs$) (loc$ arg$) (?v2 ?v1)) ?v3) (evalc$ (call$ ?v4 ?v0 ?v2) ?v1 (update$ (setlocs$ ?v3 (getlocs$ ?v1)) ?v4 (getlocs$ ?v3 res$))))) :named a140)) +(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 State$)) (=> (and (evalc$ (call$ ?v0 ?v1 ?v2) ?v3 ?v4) (forall ((?v5 State$)) (=> (and (= ?v4 (update$ (setlocs$ ?v5 (getlocs$ ?v3)) ?v0 (getlocs$ ?v5 res$))) (evalc$ (body$a ?v1) (update$ (setlocs$ ?v3 newlocs$) (loc$ arg$) (?v2 ?v3)) ?v5)) false))) false)) :named a141)) +(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 Nat$) (?v5 State$)) (=> (and (evaln$ (call$ ?v0 ?v1 ?v2) ?v3 ?v4 ?v5) (forall ((?v6 State$)) (=> (and (= ?v5 (update$ (setlocs$ ?v6 (getlocs$ ?v3)) ?v0 (getlocs$ ?v6 res$))) (evaln$ (body$a ?v1) (update$ (setlocs$ ?v3 newlocs$) (loc$ arg$) (?v2 ?v3)) ?v4 ?v6)) false))) false)) :named a142)) +(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 (-> State$ Nat$)) (?v3 Nat$) (?v4 State$) (?v5 Vname$)) (=> (evaln$ (body$a ?v0) (update$ (setlocs$ ?v1 newlocs$) (loc$ arg$) (?v2 ?v1)) ?v3 ?v4) (evaln$ (call$ ?v5 ?v0 ?v2) ?v1 ?v3 (update$ (setlocs$ ?v4 (getlocs$ ?v1)) ?v5 (getlocs$ ?v4 res$))))) :named a143)) +(assert (! (forall ((?v0 State_triple_option$) (?v1 State_triple_option$)) (=> (and (= (= ?v0 none$a) (= ?v1 none$a)) (=> (and (not (= ?v0 none$a)) (not (= ?v1 none$a))) (= (the$a ?v0) (the$a ?v1)))) (= ?v0 ?v1))) :named a144)) +(assert (! (forall ((?v0 Com_option$) (?v1 Com_option$)) (=> (and (= (= ?v0 none$) (= ?v1 none$)) (=> (and (not (= ?v0 none$)) (not (= ?v1 none$))) (= (the$ ?v0) (the$ ?v1)))) (= ?v0 ?v1))) :named a145)) +(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (and (evaln$ (body$a ?v0) ?v1 ?v2 ?v3) (forall ((?v4 Nat$)) (=> (and (= ?v2 (suc$ ?v4)) (evaln$ (the$ (body$ ?v0)) ?v1 ?v4 ?v3)) false))) false)) :named a146)) +(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (evaln$ (the$ (body$ ?v0)) ?v1 ?v2 ?v3) (evaln$ (body$a ?v0) ?v1 (suc$ ?v2) ?v3))) :named a147)) +(assert (! (forall ((?v0 State_triple_option$)) (=> (and (=> (= ?v0 none$a) false) (=> (not (= ?v0 none$a)) false)) false)) :named a148)) +(assert (! (forall ((?v0 Com_option$)) (=> (and (=> (= ?v0 none$) false) (=> (not (= ?v0 none$)) false)) false)) :named a149)) +(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (evaln$ ?v0 ?v1 ?v2 ?v3) (evaln$ ?v0 ?v1 (suc$ ?v2) ?v3))) :named a150)) +(assert (! (forall ((?v0 Pname$)) (=> (and (wt$ (body$a ?v0)) (forall ((?v1 Com$)) (=> (= (body$ ?v0) (some$ ?v1)) false))) false)) :named a151)) +(assert (! (forall ((?v0 Bool) (?v1 (-> Com$ Bool)) (?v2 Com_option$)) (! (= (case_option$ ?v0 ?v1 ?v2) (ite (= ?v2 none$) ?v0 (?v1 (the$ ?v2)))) :pattern ((case_option$ ?v0 ?v1 ?v2)))) :named a152)) +(assert (! (forall ((?v0 Glb$) (?v1 Glb$)) (= (= (glb$ ?v0) (glb$ ?v1)) (= ?v0 ?v1))) :named a153)) +(assert (! (forall ((?v0 State_triple_option$)) (= (not (= ?v0 none$a)) (exists ((?v1 State_triple$)) (= ?v0 (some$a ?v1))))) :named a154)) +(assert (! (forall ((?v0 Com_option$)) (= (not (= ?v0 none$)) (exists ((?v1 Com$)) (= ?v0 (some$ ?v1))))) :named a155)) +(assert (! (forall ((?v0 State_triple_option$)) (= (forall ((?v1 State_triple$)) (not (= ?v0 (some$a ?v1)))) (= ?v0 none$a))) :named a156)) +(assert (! (forall ((?v0 Com_option$)) (= (forall ((?v1 Com$)) (not (= ?v0 (some$ ?v1)))) (= ?v0 none$))) :named a157)) +(assert (! (forall ((?v0 State_triple_option$)) (=> (not (= ?v0 none$a)) (= (some$a (the$a ?v0)) ?v0))) :named a158)) +(assert (! (forall ((?v0 Com_option$)) (=> (not (= ?v0 none$)) (= (some$ (the$ ?v0)) ?v0))) :named a159)) +(assert (! (forall ((?v0 (-> Bool Bool)) (?v1 Bool) (?v2 (-> Com$ Bool)) (?v3 Com_option$)) (= (?v0 (case_option$ ?v1 ?v2 ?v3)) (and (=> (= ?v3 none$) (?v0 ?v1)) (=> (= ?v3 (some$ (the$ ?v3))) (?v0 (?v2 (the$ ?v3))))))) :named a160)) +(assert (! (forall ((?v0 (-> Bool Bool)) (?v1 Bool) (?v2 (-> Com$ Bool)) (?v3 Com_option$)) (= (?v0 (case_option$ ?v1 ?v2 ?v3)) (not (or (and (= ?v3 none$) (not (?v0 ?v1))) (and (= ?v3 (some$ (the$ ?v3))) (not (?v0 (?v2 (the$ ?v3))))))))) :named a161)) +(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple_option$ (-> State_triple_option$ Bool))) (?v2 State_triple_option$)) (=> (and (=> (= ?v0 none$a) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$a) (?v1 ?v0 ?v2)) (forall ((?v3 State_triple$) (?v4 State_triple$)) (=> (and (= ?v0 (some$a ?v3)) (= ?v2 (some$a ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a162)) +(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple_option$ (-> Com_option$ Bool))) (?v2 Com_option$)) (=> (and (=> (= ?v0 none$a) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$) (?v1 ?v0 ?v2)) (forall ((?v3 State_triple$) (?v4 Com$)) (=> (and (= ?v0 (some$a ?v3)) (= ?v2 (some$ ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a163)) +(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com_option$ (-> State_triple_option$ Bool))) (?v2 State_triple_option$)) (=> (and (=> (= ?v0 none$) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$a) (?v1 ?v0 ?v2)) (forall ((?v3 Com$) (?v4 State_triple$)) (=> (and (= ?v0 (some$ ?v3)) (= ?v2 (some$a ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a164)) +(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com_option$ (-> Com_option$ Bool))) (?v2 Com_option$)) (=> (and (=> (= ?v0 none$) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$) (?v1 ?v0 ?v2)) (forall ((?v3 Com$) (?v4 Com$)) (=> (and (= ?v0 (some$ ?v3)) (= ?v2 (some$ ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a165)) +(assert (! (forall ((?v0 (-> State_triple_option$ Bool))) (= (forall ((?v1 State_triple_option$)) (?v0 ?v1)) (and (?v0 none$a) (forall ((?v1 State_triple$)) (?v0 (some$a ?v1)))))) :named a166)) +(assert (! (forall ((?v0 (-> Com_option$ Bool))) (= (forall ((?v1 Com_option$)) (?v0 ?v1)) (and (?v0 none$) (forall ((?v1 Com$)) (?v0 (some$ ?v1)))))) :named a167)) +(assert (! (forall ((?v0 (-> State_triple_option$ Bool))) (= (exists ((?v1 State_triple_option$)) (?v0 ?v1)) (or (?v0 none$a) (exists ((?v1 State_triple$)) (?v0 (some$a ?v1)))))) :named a168)) +(assert (! (forall ((?v0 (-> Com_option$ Bool))) (= (exists ((?v1 Com_option$)) (?v0 ?v1)) (or (?v0 none$) (exists ((?v1 Com$)) (?v0 (some$ ?v1)))))) :named a169)) +(assert (! (forall ((?v0 State_triple_option$)) (=> (and (=> (= ?v0 none$a) false) (forall ((?v1 State_triple$)) (=> (= ?v0 (some$a ?v1)) false))) false)) :named a170)) +(assert (! (forall ((?v0 Com_option$)) (=> (and (=> (= ?v0 none$) false) (forall ((?v1 Com$)) (=> (= ?v0 (some$ ?v1)) false))) false)) :named a171)) +(assert (! (forall ((?v0 State_triple_option$) (?v1 State_triple$)) (=> (= ?v0 (some$a ?v1)) (not (= ?v0 none$a)))) :named a172)) +(assert (! (forall ((?v0 Com_option$) (?v1 Com$)) (=> (= ?v0 (some$ ?v1)) (not (= ?v0 none$)))) :named a173)) +(assert (! (forall ((?v0 State_triple$)) (not (= none$a (some$a ?v0)))) :named a174)) +(assert (! (forall ((?v0 Com$)) (not (= none$ (some$ ?v0)))) :named a175)) +(assert (! (forall ((?v0 Bool) (?v1 (-> Com$ Bool))) (! (= (case_option$ ?v0 ?v1 none$) ?v0) :pattern ((case_option$ ?v0 ?v1)))) :named a176)) +(assert (! (forall ((?v0 State_triple_option$)) (=> (and (=> (= ?v0 none$a) false) (=> (= ?v0 (some$a (the$a ?v0))) false)) false)) :named a177)) +(assert (! (forall ((?v0 Com_option$)) (=> (and (=> (= ?v0 none$) false) (=> (= ?v0 (some$ (the$ ?v0))) false)) false)) :named a178)) +(assert (! (forall ((?v0 Glb$) (?v1 Loc$)) (not (= (glb$ ?v0) (loc$ ?v1)))) :named a179)) +(assert (! (forall ((?v0 Vname$)) (=> (and (forall ((?v1 Glb$)) (=> (= ?v0 (glb$ ?v1)) false)) (forall ((?v1 Loc$)) (=> (= ?v0 (loc$ ?v1)) false))) false)) :named a180)) +(assert (! (forall ((?v0 Pname$) (?v1 Com$)) (=> (and wT_bodies$ (= (body$ ?v0) (some$ ?v1))) (wt$ ?v1))) :named a181)) +(assert (! (forall ((?v0 Nat$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool)))) (= (triple_valid$ ?v0 (triple$ ?v1 (the$ (body$ ?v2)) ?v3)) (triple_valid$ (suc$ ?v0) (triple$ ?v1 (body$a ?v2) ?v3)))) :named a182)) +(assert (! (forall ((?v0 Pname_option$)) (=> (not (= ?v0 none$b)) (member$a (the$b ?v0) (set_option$ ?v0)))) :named a183)) +(assert (! (forall ((?v0 State_triple_option$)) (=> (not (= ?v0 none$a)) (member$ (the$a ?v0) (set_option$a ?v0)))) :named a184)) +(assert (! (forall ((?v0 Com_option$)) (=> (not (= ?v0 none$)) (member$b (the$ ?v0) (set_option$b ?v0)))) :named a185)) +(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ Com_option$))) (= (= (bind$ ?v0 ?v1) none$) (or (= ?v0 none$a) (= (?v1 (the$a ?v0)) none$)))) :named a186)) +(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ State_triple_option$))) (= (= (bind$a ?v0 ?v1) none$a) (or (= ?v0 none$) (= (?v1 (the$ ?v0)) none$a)))) :named a187)) +(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ State_triple_option$))) (= (= (bind$b ?v0 ?v1) none$a) (or (= ?v0 none$a) (= (?v1 (the$a ?v0)) none$a)))) :named a188)) +(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ Com_option$))) (= (= (bind$c ?v0 ?v1) none$) (or (= ?v0 none$) (= (?v1 (the$ ?v0)) none$)))) :named a189)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Com$) (?v2 (-> State$ (-> State$ Bool))) (?v3 (-> State$ (-> State$ Bool))) (?v4 Com$) (?v5 (-> State$ (-> State$ Bool)))) (= (= (triple$ ?v0 ?v1 ?v2) (triple$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a190)) +(assert (! (forall ((?v0 Nat$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (= (triple_valid$ ?v0 (triple$ ?v1 ?v2 ?v3)) (forall ((?v4 State$) (?v5 State$)) (=> (?v1 ?v4 ?v5) (forall ((?v6 State$)) (=> (evaln$ ?v2 ?v5 ?v0 ?v6) (?v3 ?v4 ?v6))))))) :named a191)) +(assert (! (forall ((?v0 State_triple$)) (=> (forall ((?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (= ?v0 (triple$ ?v1 ?v2 ?v3)) false)) false)) :named a192)) +(assert (! (forall ((?v0 (-> Com$ State_triple_option$))) (! (= (bind$a none$ ?v0) none$a) :pattern ((bind$a none$ ?v0)))) :named a193)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$))) (! (= (bind$ none$a ?v0) none$) :pattern ((bind$ none$a ?v0)))) :named a194)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$))) (! (= (bind$b none$a ?v0) none$a) :pattern ((bind$b none$a ?v0)))) :named a195)) +(assert (! (forall ((?v0 (-> Com$ Com_option$))) (! (= (bind$c none$ ?v0) none$) :pattern ((bind$c none$ ?v0)))) :named a196)) +(assert (! (forall ((?v0 Nat$) (?v1 State_triple$)) (=> (triple_valid$ (suc$ ?v0) ?v1) (triple_valid$ ?v0 ?v1))) :named a197)) +(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ Com_option$))) (= (?v0 (bind$ ?v1 ?v2)) (and (=> (= ?v1 none$a) (?v0 none$)) (forall ((?v3 State_triple$)) (=> (= ?v1 (some$a ?v3)) (?v0 (?v2 ?v3))))))) :named a198)) +(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ State_triple_option$))) (= (?v0 (bind$b ?v1 ?v2)) (and (=> (= ?v1 none$a) (?v0 none$a)) (forall ((?v3 State_triple$)) (=> (= ?v1 (some$a ?v3)) (?v0 (?v2 ?v3))))))) :named a199)) +(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ State_triple_option$))) (= (?v0 (bind$a ?v1 ?v2)) (and (=> (= ?v1 none$) (?v0 none$a)) (forall ((?v3 Com$)) (=> (= ?v1 (some$ ?v3)) (?v0 (?v2 ?v3))))))) :named a200)) +(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ Com_option$))) (= (?v0 (bind$c ?v1 ?v2)) (and (=> (= ?v1 none$) (?v0 none$)) (forall ((?v3 Com$)) (=> (= ?v1 (some$ ?v3)) (?v0 (?v2 ?v3))))))) :named a201)) +(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ Com_option$))) (= (?v0 (bind$ ?v1 ?v2)) (not (or (and (= ?v1 none$a) (not (?v0 none$))) (exists ((?v3 State_triple$)) (and (= ?v1 (some$a ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a202)) +(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ State_triple_option$))) (= (?v0 (bind$b ?v1 ?v2)) (not (or (and (= ?v1 none$a) (not (?v0 none$a))) (exists ((?v3 State_triple$)) (and (= ?v1 (some$a ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a203)) +(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ State_triple_option$))) (= (?v0 (bind$a ?v1 ?v2)) (not (or (and (= ?v1 none$) (not (?v0 none$a))) (exists ((?v3 Com$)) (and (= ?v1 (some$ ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a204)) +(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ Com_option$))) (= (?v0 (bind$c ?v1 ?v2)) (not (or (and (= ?v1 none$) (not (?v0 none$))) (exists ((?v3 Com$)) (and (= ?v1 (some$ ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a205)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Pname$) (?v2 (-> State$ (-> State$ Bool)))) (triple_valid$ zero$ (triple$ ?v0 (body$a ?v1) ?v2))) :named a206)) +(assert (! (forall ((?v0 Pname_option$)) (= (= (set_option$ ?v0) bot$) (= ?v0 none$b))) :named a207)) +(assert (! (forall ((?v0 State_triple_option_option$)) (= (= (set_option$c ?v0) bot$a) (= ?v0 none$c))) :named a208)) +(assert (! (forall ((?v0 Com_option_option$)) (= (= (set_option$d ?v0) bot$b) (= ?v0 none$d))) :named a209)) +(assert (! (forall ((?v0 Com_option$)) (= (= (set_option$b ?v0) bot$c) (= ?v0 none$))) :named a210)) +(assert (! (forall ((?v0 State_triple_option$)) (= (= (set_option$a ?v0) bot$d) (= ?v0 none$a))) :named a211)) +(assert (! (= (set_option$ none$b) bot$) :named a212)) +(assert (! (= (set_option$c none$c) bot$a) :named a213)) +(assert (! (= (set_option$d none$d) bot$b) :named a214)) +(assert (! (= (set_option$b none$) bot$c) :named a215)) +(assert (! (= (set_option$a none$a) bot$d) :named a216)) +(assert (! (forall ((?v0 (-> State$ Nat$)) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (! (= (size_triple$ ?v0 (triple$ ?v1 ?v2 ?v3)) (suc$ zero$)) :pattern ((size_triple$ ?v0 (triple$ ?v1 ?v2 ?v3))))) :named a217)) +(assert (! (forall ((?v0 Glb$)) (! (= (size_vname$ (glb$ ?v0)) zero$) :pattern ((glb$ ?v0)))) :named a218)) +(assert (! (forall ((?v0 Loc$)) (! (= (size_vname$ (loc$ ?v0)) zero$) :pattern ((loc$ ?v0)))) :named a219)) +(assert (! (forall ((?v0 (-> State_triple$ Nat$))) (! (= (size_option$ ?v0 none$a) (suc$ zero$)) :pattern ((size_option$ ?v0)))) :named a220)) +(assert (! (forall ((?v0 (-> Com$ Nat$))) (! (= (size_option$a ?v0 none$) (suc$ zero$)) :pattern ((size_option$a ?v0)))) :named a221)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Com$) (?v2 (-> State$ (-> State$ Bool)))) (! (= (size$ (triple$ ?v0 ?v1 ?v2)) (suc$ zero$)) :pattern ((triple$ ?v0 ?v1 ?v2)))) :named a222)) +(assert (! (= (size$a none$a) (suc$ zero$)) :named a223)) +(assert (! (= (size$b none$) (suc$ zero$)) :named a224)) +(assert (! (forall ((?v0 State_triple$)) (not (= (size$ ?v0) zero$))) :named a225)) +(assert (! (forall ((?v0 Glb$)) (! (= (size$c (glb$ ?v0)) zero$) :pattern ((glb$ ?v0)))) :named a226)) +(assert (! (forall ((?v0 Loc$)) (! (= (size$c (loc$ ?v0)) zero$) :pattern ((loc$ ?v0)))) :named a227)) +(assert (! (= (size_com$ skip$) zero$) :named a228)) +(assert (! (forall ((?v0 Pname$)) (! (= (size_com$ (body$a ?v0)) zero$) :pattern ((body$a ?v0)))) :named a229)) +(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (! (= (size_com$ (call$ ?v0 ?v1 ?v2)) zero$) :pattern ((call$ ?v0 ?v1 ?v2)))) :named a230)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (! (= (size_com$ (ass$ ?v0 ?v1)) zero$) :pattern ((ass$ ?v0 ?v1)))) :named a231)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (! (= (size_com$ (local$ ?v0 ?v1 ?v2)) (plus$ (size_com$ ?v2) (suc$ zero$))) :pattern ((local$ ?v0 ?v1 ?v2)))) :named a232)) +(assert (! (forall ((?v0 Com$) (?v1 Com$)) (! (= (size_com$ (semi$ ?v0 ?v1)) (plus$ (plus$ (size_com$ ?v0) (size_com$ ?v1)) (suc$ zero$))) :pattern ((semi$ ?v0 ?v1)))) :named a233)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (! (= (size_com$ (cond$ ?v0 ?v1 ?v2)) (plus$ (plus$ (size_com$ ?v1) (size_com$ ?v2)) (suc$ zero$))) :pattern ((cond$ ?v0 ?v1 ?v2)))) :named a234)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (! (= (size_com$ (while$ ?v0 ?v1)) (plus$ (size_com$ ?v1) (suc$ zero$))) :pattern ((while$ ?v0 ?v1)))) :named a235)) +(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (! (= (size$d (local$ ?v0 ?v1 ?v2)) (plus$ (size$d ?v2) (suc$ zero$))) :pattern ((local$ ?v0 ?v1 ?v2)))) :named a236)) +(assert (! (forall ((?v0 Com$) (?v1 Com$)) (! (= (size$d (semi$ ?v0 ?v1)) (plus$ (plus$ (size$d ?v0) (size$d ?v1)) (suc$ zero$))) :pattern ((semi$ ?v0 ?v1)))) :named a237)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (! (= (size$d (cond$ ?v0 ?v1 ?v2)) (plus$ (plus$ (size$d ?v1) (size$d ?v2)) (suc$ zero$))) :pattern ((cond$ ?v0 ?v1 ?v2)))) :named a238)) +(assert (! (forall ((?v0 Pname$)) (! (= (size$d (body$a ?v0)) zero$) :pattern ((body$a ?v0)))) :named a239)) +(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (! (= (size$d (call$ ?v0 ?v1 ?v2)) zero$) :pattern ((call$ ?v0 ?v1 ?v2)))) :named a240)) +(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (! (= (size$d (ass$ ?v0 ?v1)) zero$) :pattern ((ass$ ?v0 ?v1)))) :named a241)) +(assert (! (= (size$d skip$) zero$) :named a242)) +(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (! (= (size$d (while$ ?v0 ?v1)) (plus$ (size$d ?v1) (suc$ zero$))) :pattern ((while$ ?v0 ?v1)))) :named a243)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool))) (?v4 State$) (?v5 Vname$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (body$a ?v2) (uuc$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uud$ ?v1 ?v4 ?v6) (call$ ?v5 ?v2 ?v6) ?v3) bot$d)))) :named a244)) +(assert (! (forall ((?v0 Com_option$)) (= (bind$c ?v0 uue$) none$)) :named a245)) +(assert (! (forall ((?v0 Bool) (?v1 (-> State_triple$ Bool)) (?v2 State_triple_option$)) (=> (and (case_option$a ?v0 ?v1 ?v2) (and (=> (and (= ?v2 none$a) ?v0) false) (forall ((?v3 State_triple$)) (=> (and (= ?v2 (some$a ?v3)) (?v1 ?v3)) false)))) false)) :named a246)) +(assert (! (forall ((?v0 Bool) (?v1 (-> Com$ Bool)) (?v2 Com_option$)) (=> (and (case_option$ ?v0 ?v1 ?v2) (and (=> (and (= ?v2 none$) ?v0) false) (forall ((?v3 Com$)) (=> (and (= ?v2 (some$ ?v3)) (?v1 ?v3)) false)))) false)) :named a247)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple_set$) (?v2 State_triple_set$)) (=> (and (hoare_derivs$ ?v0 ?v1) (hoare_derivs$ ?v2 ?v0)) (hoare_derivs$ ?v2 ?v1))) :named a248)) +(assert (! (forall ((?v0 State_triple_option$)) (= (not (= ?v0 none$a)) (case_option$a false uuf$ ?v0))) :named a249)) +(assert (! (forall ((?v0 Com_option$)) (= (not (= ?v0 none$)) (case_option$ false uug$ ?v0))) :named a250)) +(assert (! (forall ((?v0 State_triple_option$)) (= (= ?v0 none$a) (case_option$a true uuh$ ?v0))) :named a251)) +(assert (! (forall ((?v0 Com_option$)) (= (= ?v0 none$) (case_option$ true uui$ ?v0))) :named a252)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (hoare_derivs$ ?v0 (insert$ ?v1 ?v2)) (and (hoare_derivs$ ?v0 (insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)))) :named a253)) +(assert (! (forall ((?v0 State_triple_set$)) (hoare_derivs$ ?v0 bot$d)) :named a254)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (and (hoare_derivs$ ?v0 (insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)) (hoare_derivs$ ?v0 (insert$ ?v1 ?v2)))) :named a255)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Loc$) (?v5 State$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 (uuj$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uuk$ ?v1 ?v4 ?v5 ?v6) (local$ ?v4 ?v6 ?v2) ?v3) bot$d)))) :named a256)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (hoare_derivs$ ?v0 (insert$ (triple$ (uul$ ?v1 ?v2) (while$ ?v2 ?v3) ?v1) bot$d))) :named a257)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Com$) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v3 ?v4 ?v5) bot$d))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (semi$ ?v2 ?v4) ?v5) bot$d)))) :named a258)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 skip$ ?v1) bot$d))) :named a259)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (exists ((?v6 (-> State$ (-> State$ Bool))) (?v7 (-> State$ (-> State$ Bool)))) (and (hoare_derivs$ ?v1 (insert$ (triple$ ?v6 ?v2 ?v7) bot$d)) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v6 ?v9 ?v5) (?v7 ?v9 ?v8))) (?v3 ?v4 ?v8))))))) (hoare_derivs$ ?v1 (insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a260)) +(assert (! (forall ((?v0 Bool) (?v1 State_triple_set$) (?v2 (-> State$ (-> State$ Bool))) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool)))) (=> (=> ?v0 (hoare_derivs$ ?v1 (insert$ (triple$ ?v2 ?v3 ?v4) bot$d))) (hoare_derivs$ ?v1 (insert$ (triple$ (uum$ ?v0 ?v2) ?v3 ?v4) bot$d)))) :named a261)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool))) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v6 State$) (?v7 State$)) (=> (?v4 ?v6 ?v7) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v1 ?v9 ?v7) (?v3 ?v9 ?v8))) (?v5 ?v6 ?v8)))))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v4 ?v2 ?v5) bot$d)))) :named a262)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v3 ?v5 ?v6) (?v4 ?v5 ?v6)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v4) bot$d)))) :named a263)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v4 ?v5 ?v6) (?v1 ?v5 ?v6)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v4 ?v2 ?v3) bot$d)))) :named a264)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (hoare_derivs$ ?v1 (insert$ (triple$ (uun$ ?v5) ?v2 (uuo$ ?v3 ?v4)) bot$d)))) (hoare_derivs$ ?v1 (insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a265)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Vname$) (?v3 (-> State$ Nat$))) (hoare_derivs$ ?v0 (insert$ (triple$ (uup$ ?v1 ?v2 ?v3) (ass$ ?v2 ?v3) ?v1) bot$d))) :named a266)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Pname$) (?v2 (-> State$ (-> State$ Bool))) (?v3 State_triple_set$)) (=> (hoare_derivs$ (insert$ (triple$ ?v0 (body$a ?v1) ?v2) ?v3) (insert$ (triple$ ?v0 (the$ (body$ ?v1)) ?v2) bot$d)) (hoare_derivs$ ?v3 (insert$ (triple$ ?v0 (body$a ?v1) ?v2) bot$d)))) :named a267)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool)))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (the$ (body$ ?v2)) ?v3) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (body$a ?v2) ?v3) bot$d)))) :named a268)) +(assert (! (forall ((?v0 Com$)) (! (= (mgt$ ?v0) (triple$ uuq$ ?v0 (evalc$ ?v0))) :pattern ((mgt$ ?v0)))) :named a269)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$) (?v4 Pname$)) (=> (and (hoare_derivs$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (member$a ?v4 ?v3)) (hoare_derivs$ ?v0 (insert$ (triple$ (?v1 ?v4) (body$a ?v4) (?v2 ?v4)) bot$d)))) :named a270)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool))) (?v5 Com$)) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v4) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 (comp$ uut$ ?v2)) ?v5 ?v4) bot$d))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (cond$ ?v2 ?v3 ?v5) ?v4) bot$d)))) :named a271)) +(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 (-> State$ Bool)) (?v2 State$) (?v3 State$)) (! (= (peek_and$ ?v0 ?v1 ?v2 ?v3) (and (?v0 ?v2 ?v3) (?v1 ?v3))) :pattern ((peek_and$ ?v0 ?v1 ?v2 ?v3)))) :named a272)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$)) (=> (hoare_derivs$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (hoare_derivs$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)))) :named a273)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a274)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$)) (=> (hoare_valids$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (hoare_valids$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)))) :named a275)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_valids$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_valids$ ?v0 (insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a276)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple_set$)) (=> (hoare_derivs$ ?v0 ?v1) (hoare_valids$ ?v0 ?v1))) :named a277)) +(assert (! (forall ((?v0 Pname_set$) (?v1 State_triple_set$) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 (-> Pname$ Com$)) (?v4 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v5 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v6 (-> Pname$ (-> State$ (-> State$ Bool))))) (=> (and (finite$ ?v0) (and (forall ((?v7 Pname$)) (=> (hoare_derivs$ ?v1 (insert$ (triple$ (?v2 ?v7) (?v3 ?v7) (?v4 ?v7)) bot$d)) (hoare_derivs$ ?v1 (insert$ (triple$ (?v5 ?v7) (?v3 ?v7) (?v6 ?v7)) bot$d)))) (hoare_derivs$ ?v1 (image$ (uuu$ ?v2 ?v3 ?v4) ?v0)))) (hoare_derivs$ ?v1 (image$ (uuv$ ?v3 ?v5 ?v6) ?v0)))) :named a278)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 Com$)) (=> (hoare_derivs$ ?v0 (insert$ (mgt$ ?v1) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uuw$ ?v1) ?v1 uuq$) bot$d)))) :named a279)) +(assert (! (forall ((?v0 Nat$) (?v1 State_triple$)) (= (triple_valid$ ?v0 ?v1) (case_triple$ (uux$ ?v0) ?v1))) :named a280)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$ (fun_upd$ ?v0 ?v1 (some$ ?v2))) (insert$a ?v2 (ran$ ?v0))))) :named a281)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$a (fun_upd$a ?v0 ?v1 (some$ ?v2))) (insert$a ?v2 (ran$a ?v0))))) :named a282)) +(assert (! (forall ((?v0 State_triple$) (?v1 State_triple$)) (= (fun_upd$ uuy$ ?v0 none$ ?v1) none$)) :named a283)) +(assert (! (forall ((?v0 Pname$) (?v1 Pname$)) (= (fun_upd$a uuz$ ?v0 none$ ?v1) none$)) :named a284)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com$)) (not (= (fun_upd$ ?v0 ?v1 (some$ ?v2)) uuy$))) :named a285)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com$)) (not (= (fun_upd$a ?v0 ?v1 (some$ ?v2)) uuz$))) :named a286)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$)) (= (= (dom$ ?v0) (insert$ ?v1 bot$d)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$b uva$ ?v1 (some$a ?v2)))))) :named a287)) +(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$)) (= (= (dom$a ?v0) (insert$a ?v1 bot$c)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$c uvb$ ?v1 (some$a ?v2)))))) :named a288)) +(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$)) (= (= (dom$b ?v0) (insert$a ?v1 bot$c)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$d uue$ ?v1 (some$ ?v2)))))) :named a289)) +(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$)) (= (= (dom$c ?v0) (insert$b ?v1 bot$)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$e uvc$ ?v1 (some$a ?v2)))))) :named a290)) +(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$)) (= (= (dom$d ?v0) (insert$c ?v1 bot$a)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$f uvd$ ?v1 (some$a ?v2)))))) :named a291)) +(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$)) (= (= (dom$e ?v0) (insert$c ?v1 bot$a)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$g uve$ ?v1 (some$ ?v2)))))) :named a292)) +(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$)) (= (= (dom$f ?v0) (insert$d ?v1 bot$b)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$h uvf$ ?v1 (some$a ?v2)))))) :named a293)) +(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$)) (= (= (dom$g ?v0) (insert$d ?v1 bot$b)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$i uvg$ ?v1 (some$ ?v2)))))) :named a294)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (= (= (dom$h ?v0) (insert$b ?v1 bot$)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$a uuz$ ?v1 (some$ ?v2)))))) :named a295)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (= (dom$i ?v0) (insert$ ?v1 bot$d)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$ uuy$ ?v1 (some$ ?v2)))))) :named a296)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 (-> State_triple$ Com_option$)) (?v2 State_triple$) (?v3 Com$)) (=> (map_le$ ?v0 ?v1) (map_le$ (fun_upd$ ?v0 ?v2 none$) (fun_upd$ ?v1 ?v2 (some$ ?v3))))) :named a297)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 (-> Pname$ Com_option$)) (?v2 Pname$) (?v3 Com$)) (=> (map_le$a ?v0 ?v1) (map_le$a (fun_upd$a ?v0 ?v2 none$) (fun_upd$a ?v1 ?v2 (some$ ?v3))))) :named a298)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$))) (= (= (dom$ ?v0) bot$d) (= ?v0 uva$))) :named a299)) +(assert (! (forall ((?v0 (-> Com$ Com_option$))) (= (= (dom$b ?v0) bot$c) (= ?v0 uue$))) :named a300)) +(assert (! (forall ((?v0 (-> Com$ State_triple_option$))) (= (= (dom$a ?v0) bot$c) (= ?v0 uvb$))) :named a301)) +(assert (! (forall ((?v0 (-> Pname$ State_triple_option$))) (= (= (dom$c ?v0) bot$) (= ?v0 uvc$))) :named a302)) +(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$))) (= (= (dom$e ?v0) bot$a) (= ?v0 uve$))) :named a303)) +(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$))) (= (= (dom$d ?v0) bot$a) (= ?v0 uvd$))) :named a304)) +(assert (! (forall ((?v0 (-> Com_option$ Com_option$))) (= (= (dom$g ?v0) bot$b) (= ?v0 uvg$))) :named a305)) +(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$))) (= (= (dom$f ?v0) bot$b) (= ?v0 uvf$))) :named a306)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$))) (= (= (dom$h ?v0) bot$) (= ?v0 uuz$))) :named a307)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$))) (= (= (dom$i ?v0) bot$d) (= ?v0 uuy$))) :named a308)) +(assert (! (= (dom$ uva$) bot$d) :named a309)) +(assert (! (= (dom$b uue$) bot$c) :named a310)) +(assert (! (= (dom$a uvb$) bot$c) :named a311)) +(assert (! (= (dom$c uvc$) bot$) :named a312)) +(assert (! (= (dom$e uve$) bot$a) :named a313)) +(assert (! (= (dom$d uvd$) bot$a) :named a314)) +(assert (! (= (dom$g uvg$) bot$b) :named a315)) +(assert (! (= (dom$f uvf$) bot$b) :named a316)) +(assert (! (= (dom$h uuz$) bot$) :named a317)) +(assert (! (= (dom$i uuy$) bot$d) :named a318)) +(assert (! (finite$ (dom$h body$)) :named a319)) +(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Com_option$))) (= (member$b ?v0 (dom$b ?v1)) (not (= (?v1 ?v0) none$)))) :named a320)) +(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Com_option$))) (= (member$ ?v0 (dom$i ?v1)) (not (= (?v1 ?v0) none$)))) :named a321)) +(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ State_triple_option$))) (= (member$b ?v0 (dom$a ?v1)) (not (= (?v1 ?v0) none$a)))) :named a322)) +(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ State_triple_option$))) (= (member$a ?v0 (dom$c ?v1)) (not (= (?v1 ?v0) none$a)))) :named a323)) +(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ State_triple_option$))) (= (member$ ?v0 (dom$ ?v1)) (not (= (?v1 ?v0) none$a)))) :named a324)) +(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Com_option$))) (= (member$a ?v0 (dom$h ?v1)) (not (= (?v1 ?v0) none$)))) :named a325)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$))) (= (dom$i ?v0) (collect$a (uvh$ ?v0)))) :named a326)) +(assert (! (forall ((?v0 (-> Pname$ State_triple_option$))) (= (dom$c ?v0) (collect$b (uvi$ ?v0)))) :named a327)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$))) (= (dom$h ?v0) (collect$b (uvj$ ?v0)))) :named a328)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (map_le$ (fun_upd$ ?v0 ?v1 none$) ?v0)) :named a329)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (map_le$a (fun_upd$a ?v0 ?v1 none$) ?v0)) :named a330)) +(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$) (?v2 Com_option$)) (= (dom$b (fun_upd$d ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$ (dom$b ?v0) (insert$a ?v1 bot$c)) (insert$a ?v1 (dom$b ?v0))))) :named a331)) +(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$) (?v2 State_triple_option$)) (= (dom$a (fun_upd$c ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$ (dom$a ?v0) (insert$a ?v1 bot$c)) (insert$a ?v1 (dom$a ?v0))))) :named a332)) +(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 Com_option$)) (= (dom$e (fun_upd$g ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$a (dom$e ?v0) (insert$c ?v1 bot$a)) (insert$c ?v1 (dom$e ?v0))))) :named a333)) +(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option$)) (= (dom$d (fun_upd$f ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$a (dom$d ?v0) (insert$c ?v1 bot$a)) (insert$c ?v1 (dom$d ?v0))))) :named a334)) +(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option$)) (= (dom$g (fun_upd$i ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$b (dom$g ?v0) (insert$d ?v1 bot$b)) (insert$d ?v1 (dom$g ?v0))))) :named a335)) +(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 State_triple_option$)) (= (dom$f (fun_upd$h ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$b (dom$f ?v0) (insert$d ?v1 bot$b)) (insert$d ?v1 (dom$f ?v0))))) :named a336)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_option$)) (= (dom$ (fun_upd$b ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$c (dom$ ?v0) (insert$ ?v1 bot$d)) (insert$ ?v1 (dom$ ?v0))))) :named a337)) +(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 State_triple_option$)) (= (dom$c (fun_upd$e ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$d (dom$c ?v0) (insert$b ?v1 bot$)) (insert$b ?v1 (dom$c ?v0))))) :named a338)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com_option$)) (= (dom$h (fun_upd$a ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$d (dom$h ?v0) (insert$b ?v1 bot$)) (insert$b ?v1 (dom$h ?v0))))) :named a339)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com_option$)) (= (dom$i (fun_upd$ ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$c (dom$i ?v0) (insert$ ?v1 bot$d)) (insert$ ?v1 (dom$i ?v0))))) :named a340)) +(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (map_option$ ?v0 ?v1) (case_option$b none$ (uvk$ ?v0) ?v1))) :named a341)) +(assert (! (forall ((?v0 (-> State_triple$ Com$)) (?v1 State_triple_option$)) (= (= (map_option$a ?v0 ?v1) none$) (= ?v1 none$a))) :named a342)) +(assert (! (forall ((?v0 (-> Com$ State_triple$)) (?v1 Com_option$)) (= (= (map_option$b ?v0 ?v1) none$a) (= ?v1 none$))) :named a343)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple$)) (?v1 State_triple_option$)) (= (= (map_option$c ?v0 ?v1) none$a) (= ?v1 none$a))) :named a344)) +(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (= (map_option$ ?v0 ?v1) none$) (= ?v1 none$))) :named a345)) +(assert (! (forall ((?v0 (-> State_triple$ Com$)) (?v1 State_triple_option$)) (= (= (map_option$a ?v0 ?v1) none$) (= ?v1 none$a))) :named a346)) +(assert (! (forall ((?v0 (-> Com$ State_triple$)) (?v1 Com_option$)) (= (= (map_option$b ?v0 ?v1) none$a) (= ?v1 none$))) :named a347)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple$)) (?v1 State_triple_option$)) (= (= (map_option$c ?v0 ?v1) none$a) (= ?v1 none$a))) :named a348)) +(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (= (map_option$ ?v0 ?v1) none$) (= ?v1 none$))) :named a349)) +(assert (! (forall ((?v0 (-> State_triple$ Com$)) (?v1 State_triple_option$)) (= (= none$ (map_option$a ?v0 ?v1)) (= ?v1 none$a))) :named a350)) +(assert (! (forall ((?v0 (-> Com$ State_triple$)) (?v1 Com_option$)) (= (= none$a (map_option$b ?v0 ?v1)) (= ?v1 none$))) :named a351)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple$)) (?v1 State_triple_option$)) (= (= none$a (map_option$c ?v0 ?v1)) (= ?v1 none$a))) :named a352)) +(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (= none$ (map_option$ ?v0 ?v1)) (= ?v1 none$))) :named a353)) +(assert (! (forall ((?v0 (-> Com$ State_triple$))) (! (= (map_option$b ?v0 none$) none$a) :pattern ((map_option$b ?v0)))) :named a354)) +(assert (! (forall ((?v0 (-> State_triple$ Com$))) (! (= (map_option$a ?v0 none$a) none$) :pattern ((map_option$a ?v0)))) :named a355)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple$))) (! (= (map_option$c ?v0 none$a) none$a) :pattern ((map_option$c ?v0)))) :named a356)) +(assert (! (forall ((?v0 (-> Com$ Com$))) (! (= (map_option$ ?v0 none$) none$) :pattern ((map_option$ ?v0)))) :named a357)) +(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ Com$))) (=> (not (= ?v0 none$a)) (= (the$ (map_option$a ?v1 ?v0)) (?v1 (the$a ?v0))))) :named a358)) +(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ Com$))) (=> (not (= ?v0 none$)) (= (the$ (map_option$ ?v1 ?v0)) (?v1 (the$ ?v0))))) :named a359)) +(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$a (dom$e ?v0) (insert$c ?v1 ?v2)) (minus$a (dom$e ?v0) ?v2)))) :named a360)) +(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$b (dom$g ?v0) (insert$d ?v1 ?v2)) (minus$b (dom$g ?v0) ?v2)))) :named a361)) +(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$a (dom$d ?v0) (insert$c ?v1 ?v2)) (minus$a (dom$d ?v0) ?v2)))) :named a362)) +(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$b (dom$f ?v0) (insert$d ?v1 ?v2)) (minus$b (dom$f ?v0) ?v2)))) :named a363)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$c (dom$ ?v0) (insert$ ?v1 ?v2)) (minus$c (dom$ ?v0) ?v2)))) :named a364)) +(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$d (dom$c ?v0) (insert$b ?v1 ?v2)) (minus$d (dom$c ?v0) ?v2)))) :named a365)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$) (= (minus$d (dom$h ?v0) (insert$b ?v1 ?v2)) (minus$d (dom$h ?v0) ?v2)))) :named a366)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$) (= (minus$c (dom$i ?v0) (insert$ ?v1 ?v2)) (minus$c (dom$i ?v0) ?v2)))) :named a367)) +(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$d (restrict_map$ ?v0 ?v1) ?v2 none$) (ite (member$b ?v2 ?v1) (restrict_map$ ?v0 (minus$ ?v1 (insert$a ?v2 bot$c))) (restrict_map$ ?v0 ?v1)))) :named a368)) +(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$c (restrict_map$a ?v0 ?v1) ?v2 none$a) (ite (member$b ?v2 ?v1) (restrict_map$a ?v0 (minus$ ?v1 (insert$a ?v2 bot$c))) (restrict_map$a ?v0 ?v1)))) :named a369)) +(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$g (restrict_map$b ?v0 ?v1) ?v2 none$) (ite (member$c ?v2 ?v1) (restrict_map$b ?v0 (minus$a ?v1 (insert$c ?v2 bot$a))) (restrict_map$b ?v0 ?v1)))) :named a370)) +(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$f (restrict_map$c ?v0 ?v1) ?v2 none$a) (ite (member$c ?v2 ?v1) (restrict_map$c ?v0 (minus$a ?v1 (insert$c ?v2 bot$a))) (restrict_map$c ?v0 ?v1)))) :named a371)) +(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$i (restrict_map$d ?v0 ?v1) ?v2 none$) (ite (member$d ?v2 ?v1) (restrict_map$d ?v0 (minus$b ?v1 (insert$d ?v2 bot$b))) (restrict_map$d ?v0 ?v1)))) :named a372)) +(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$h (restrict_map$e ?v0 ?v1) ?v2 none$a) (ite (member$d ?v2 ?v1) (restrict_map$e ?v0 (minus$b ?v1 (insert$d ?v2 bot$b))) (restrict_map$e ?v0 ?v1)))) :named a373)) +(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$b (restrict_map$f ?v0 ?v1) ?v2 none$a) (ite (member$ ?v2 ?v1) (restrict_map$f ?v0 (minus$c ?v1 (insert$ ?v2 bot$d))) (restrict_map$f ?v0 ?v1)))) :named a374)) +(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$a (restrict_map$g ?v0 ?v1) ?v2 none$) (ite (member$a ?v2 ?v1) (restrict_map$g ?v0 (minus$d ?v1 (insert$b ?v2 bot$))) (restrict_map$g ?v0 ?v1)))) :named a375)) +(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$e (restrict_map$h ?v0 ?v1) ?v2 none$a) (ite (member$a ?v2 ?v1) (restrict_map$h ?v0 (minus$d ?v1 (insert$b ?v2 bot$))) (restrict_map$h ?v0 ?v1)))) :named a376)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$ (restrict_map$i ?v0 ?v1) ?v2 none$) (ite (member$ ?v2 ?v1) (restrict_map$i ?v0 (minus$c ?v1 (insert$ ?v2 bot$d))) (restrict_map$i ?v0 ?v1)))) :named a377)) +(assert (! (forall ((?v0 Pname_option_set$)) (= (not (= (these$ ?v0) bot$)) (and (not (= ?v0 bot$e)) (not (= ?v0 (insert$e none$b bot$e)))))) :named a378)) +(assert (! (forall ((?v0 State_triple_option_option_set$)) (= (not (= (these$a ?v0) bot$a)) (and (not (= ?v0 bot$f)) (not (= ?v0 (insert$f none$c bot$f)))))) :named a379)) +(assert (! (forall ((?v0 Com_option_option_set$)) (= (not (= (these$b ?v0) bot$b)) (and (not (= ?v0 bot$g)) (not (= ?v0 (insert$g none$d bot$g)))))) :named a380)) +(assert (! (forall ((?v0 Com_option_set$)) (= (not (= (these$c ?v0) bot$c)) (and (not (= ?v0 bot$b)) (not (= ?v0 (insert$d none$ bot$b)))))) :named a381)) +(assert (! (forall ((?v0 State_triple_option_set$)) (= (not (= (these$d ?v0) bot$d)) (and (not (= ?v0 bot$a)) (not (= ?v0 (insert$c none$a bot$a)))))) :named a382)) +(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ Com_option$))) (! (=> (not (member$b ?v0 ?v1)) (= (restrict_map$ ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$ ?v2 ?v1 ?v0)))) :named a383)) +(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ Com_option$))) (! (=> (not (member$a ?v0 ?v1)) (= (restrict_map$g ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$g ?v2 ?v1 ?v0)))) :named a384)) +(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ Com_option$))) (! (=> (not (member$ ?v0 ?v1)) (= (restrict_map$i ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$i ?v2 ?v1 ?v0)))) :named a385)) +(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ State_triple_option$))) (! (=> (not (member$b ?v0 ?v1)) (= (restrict_map$a ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$a ?v2 ?v1 ?v0)))) :named a386)) +(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ State_triple_option$))) (! (=> (not (member$a ?v0 ?v1)) (= (restrict_map$h ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$h ?v2 ?v1 ?v0)))) :named a387)) +(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ State_triple_option$))) (! (=> (not (member$ ?v0 ?v1)) (= (restrict_map$f ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$f ?v2 ?v1 ?v0)))) :named a388)) +(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$)) (= (restrict_map$i uuy$ ?v0 ?v1) none$)) :named a389)) +(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$)) (= (restrict_map$d ?v0 bot$b ?v1) none$)) :named a390)) +(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$)) (= (restrict_map$e ?v0 bot$b ?v1) none$a)) :named a391)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (restrict_map$i ?v0 bot$d ?v1) none$)) :named a392)) +(assert (! (forall ((?v0 Com_option_set$)) (= (these$c (insert$d none$ ?v0)) (these$c ?v0))) :named a393)) +(assert (! (forall ((?v0 Com_option_set$)) (= (= (these$c ?v0) bot$c) (or (= ?v0 bot$b) (= ?v0 (insert$d none$ bot$b))))) :named a394)) +(assert (! (forall ((?v0 State_triple_option_set$)) (= (= (these$d ?v0) bot$d) (or (= ?v0 bot$a) (= ?v0 (insert$c none$a bot$a))))) :named a395)) +(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (restrict_map$i ?v0 (uminus$ (insert$ ?v1 bot$d))) (fun_upd$ ?v0 ?v1 none$))) :named a396)) +(check-sat) +;(get-proof) diff --git a/test/regress/regress1/hole6.cvc b/test/regress/regress1/hole6.cvc new file mode 100644 index 000000000..dfa9b72d5 --- /dev/null +++ b/test/regress/regress1/hole6.cvc @@ -0,0 +1,179 @@ +% EXPECT: valid +x_1 : BOOLEAN; +x_2 : BOOLEAN; +x_3 : BOOLEAN; +x_4 : BOOLEAN; +x_5 : BOOLEAN; +x_6 : BOOLEAN; +x_7 : BOOLEAN; +x_8 : BOOLEAN; +x_9 : BOOLEAN; +x_10 : BOOLEAN; +x_11 : BOOLEAN; +x_12 : BOOLEAN; +x_13 : BOOLEAN; +x_14 : BOOLEAN; +x_15 : BOOLEAN; +x_16 : BOOLEAN; +x_17 : BOOLEAN; +x_18 : BOOLEAN; +x_19 : BOOLEAN; +x_20 : BOOLEAN; +x_21 : BOOLEAN; +x_22 : BOOLEAN; +x_23 : BOOLEAN; +x_24 : BOOLEAN; +x_25 : BOOLEAN; +x_26 : BOOLEAN; +x_27 : BOOLEAN; +x_28 : BOOLEAN; +x_29 : BOOLEAN; +x_30 : BOOLEAN; +x_31 : BOOLEAN; +x_32 : BOOLEAN; +x_33 : BOOLEAN; +x_34 : BOOLEAN; +x_35 : BOOLEAN; +x_36 : BOOLEAN; +x_37 : BOOLEAN; +x_38 : BOOLEAN; +x_39 : BOOLEAN; +x_40 : BOOLEAN; +x_41 : BOOLEAN; +x_42 : BOOLEAN; +ASSERT NOT x_1 OR NOT x_7; +ASSERT NOT x_1 OR NOT x_13; +ASSERT NOT x_1 OR NOT x_19; +ASSERT NOT x_1 OR NOT x_25; +ASSERT NOT x_1 OR NOT x_31; +ASSERT NOT x_1 OR NOT x_37; +ASSERT NOT x_7 OR NOT x_13; +ASSERT NOT x_7 OR NOT x_19; +ASSERT NOT x_7 OR NOT x_25; +ASSERT NOT x_7 OR NOT x_31; +ASSERT NOT x_7 OR NOT x_37; +ASSERT NOT x_13 OR NOT x_19; +ASSERT NOT x_13 OR NOT x_25; +ASSERT NOT x_13 OR NOT x_31; +ASSERT NOT x_13 OR NOT x_37; +ASSERT NOT x_19 OR NOT x_25; +ASSERT NOT x_19 OR NOT x_31; +ASSERT NOT x_19 OR NOT x_37; +ASSERT NOT x_25 OR NOT x_31; +ASSERT NOT x_25 OR NOT x_37; +ASSERT NOT x_31 OR NOT x_37; +ASSERT NOT x_2 OR NOT x_8; +ASSERT NOT x_2 OR NOT x_14; +ASSERT NOT x_2 OR NOT x_20; +ASSERT NOT x_2 OR NOT x_26; +ASSERT NOT x_2 OR NOT x_32; +ASSERT NOT x_2 OR NOT x_38; +ASSERT NOT x_8 OR NOT x_14; +ASSERT NOT x_8 OR NOT x_20; +ASSERT NOT x_8 OR NOT x_26; +ASSERT NOT x_8 OR NOT x_32; +ASSERT NOT x_8 OR NOT x_38; +ASSERT NOT x_14 OR NOT x_20; +ASSERT NOT x_14 OR NOT x_26; +ASSERT NOT x_14 OR NOT x_32; +ASSERT NOT x_14 OR NOT x_38; +ASSERT NOT x_20 OR NOT x_26; +ASSERT NOT x_20 OR NOT x_32; +ASSERT NOT x_20 OR NOT x_38; +ASSERT NOT x_26 OR NOT x_32; +ASSERT NOT x_26 OR NOT x_38; +ASSERT NOT x_32 OR NOT x_38; +ASSERT NOT x_3 OR NOT x_9; +ASSERT NOT x_3 OR NOT x_15; +ASSERT NOT x_3 OR NOT x_21; +ASSERT NOT x_3 OR NOT x_27; +ASSERT NOT x_3 OR NOT x_33; +ASSERT NOT x_3 OR NOT x_39; +ASSERT NOT x_9 OR NOT x_15; +ASSERT NOT x_9 OR NOT x_21; +ASSERT NOT x_9 OR NOT x_27; +ASSERT NOT x_9 OR NOT x_33; +ASSERT NOT x_9 OR NOT x_39; +ASSERT NOT x_15 OR NOT x_21; +ASSERT NOT x_15 OR NOT x_27; +ASSERT NOT x_15 OR NOT x_33; +ASSERT NOT x_15 OR NOT x_39; +ASSERT NOT x_21 OR NOT x_27; +ASSERT NOT x_21 OR NOT x_33; +ASSERT NOT x_21 OR NOT x_39; +ASSERT NOT x_27 OR NOT x_33; +ASSERT NOT x_27 OR NOT x_39; +ASSERT NOT x_33 OR NOT x_39; +ASSERT NOT x_4 OR NOT x_10; +ASSERT NOT x_4 OR NOT x_16; +ASSERT NOT x_4 OR NOT x_22; +ASSERT NOT x_4 OR NOT x_28; +ASSERT NOT x_4 OR NOT x_34; +ASSERT NOT x_4 OR NOT x_40; +ASSERT NOT x_10 OR NOT x_16; +ASSERT NOT x_10 OR NOT x_22; +ASSERT NOT x_10 OR NOT x_28; +ASSERT NOT x_10 OR NOT x_34; +ASSERT NOT x_10 OR NOT x_40; +ASSERT NOT x_16 OR NOT x_22; +ASSERT NOT x_16 OR NOT x_28; +ASSERT NOT x_16 OR NOT x_34; +ASSERT NOT x_16 OR NOT x_40; +ASSERT NOT x_22 OR NOT x_28; +ASSERT NOT x_22 OR NOT x_34; +ASSERT NOT x_22 OR NOT x_40; +ASSERT NOT x_28 OR NOT x_34; +ASSERT NOT x_28 OR NOT x_40; +ASSERT NOT x_34 OR NOT x_40; +ASSERT NOT x_5 OR NOT x_11; +ASSERT NOT x_5 OR NOT x_17; +ASSERT NOT x_5 OR NOT x_23; +ASSERT NOT x_5 OR NOT x_29; +ASSERT NOT x_5 OR NOT x_35; +ASSERT NOT x_5 OR NOT x_41; +ASSERT NOT x_11 OR NOT x_17; +ASSERT NOT x_11 OR NOT x_23; +ASSERT NOT x_11 OR NOT x_29; +ASSERT NOT x_11 OR NOT x_35; +ASSERT NOT x_11 OR NOT x_41; +ASSERT NOT x_17 OR NOT x_23; +ASSERT NOT x_17 OR NOT x_29; +ASSERT NOT x_17 OR NOT x_35; +ASSERT NOT x_17 OR NOT x_41; +ASSERT NOT x_23 OR NOT x_29; +ASSERT NOT x_23 OR NOT x_35; +ASSERT NOT x_23 OR NOT x_41; +ASSERT NOT x_29 OR NOT x_35; +ASSERT NOT x_29 OR NOT x_41; +ASSERT NOT x_35 OR NOT x_41; +ASSERT NOT x_6 OR NOT x_12; +ASSERT NOT x_6 OR NOT x_18; +ASSERT NOT x_6 OR NOT x_24; +ASSERT NOT x_6 OR NOT x_30; +ASSERT NOT x_6 OR NOT x_36; +ASSERT NOT x_6 OR NOT x_42; +ASSERT NOT x_12 OR NOT x_18; +ASSERT NOT x_12 OR NOT x_24; +ASSERT NOT x_12 OR NOT x_30; +ASSERT NOT x_12 OR NOT x_36; +ASSERT NOT x_12 OR NOT x_42; +ASSERT NOT x_18 OR NOT x_24; +ASSERT NOT x_18 OR NOT x_30; +ASSERT NOT x_18 OR NOT x_36; +ASSERT NOT x_18 OR NOT x_42; +ASSERT NOT x_24 OR NOT x_30; +ASSERT NOT x_24 OR NOT x_36; +ASSERT NOT x_24 OR NOT x_42; +ASSERT NOT x_30 OR NOT x_36; +ASSERT NOT x_30 OR NOT x_42; +ASSERT NOT x_36 OR NOT x_42; +ASSERT x_6 OR x_5 OR x_4 OR x_3 OR x_2 OR x_1; +ASSERT x_12 OR x_11 OR x_10 OR x_9 OR x_8 OR x_7; +ASSERT x_18 OR x_17 OR x_16 OR x_15 OR x_14 OR x_13; +ASSERT x_24 OR x_23 OR x_22 OR x_21 OR x_20 OR x_19; +ASSERT x_30 OR x_29 OR x_28 OR x_27 OR x_26 OR x_25; +ASSERT x_36 OR x_35 OR x_34 OR x_33 OR x_32 OR x_31; +ASSERT x_42 OR x_41 OR x_40 OR x_39 OR x_38 OR x_37; + + +QUERY FALSE; diff --git a/test/regress/regress1/issue1048-arrays-int-real.smt2 b/test/regress/regress1/issue1048-arrays-int-real.smt2 new file mode 100644 index 000000000..6bbfe4cb7 --- /dev/null +++ b/test/regress/regress1/issue1048-arrays-int-real.smt2 @@ -0,0 +1,6 @@ +(set-logic QF_ALIRA) +(declare-fun a () (Array Int Real)) +(declare-fun b () (Array Int Int)) +(assert (= a b)) +(assert (= (select a 0) 0.5)) +(check-sat) diff --git a/test/regress/regress1/ite5.smt2 b/test/regress/regress1/ite5.smt2 new file mode 100644 index 000000000..e3d2bc9b8 --- /dev/null +++ b/test/regress/regress1/ite5.smt2 @@ -0,0 +1,8 @@ +(set-logic QF_AUFBV ) +(set-info :status sat) +(declare-fun arr0 () (Array (_ BitVec 32) (_ BitVec 8) ) ) +(declare-fun arr1 () (Array (_ BitVec 32) (_ BitVec 8) ) ) +(declare-fun arr2 () (Array (_ BitVec 32) (_ BitVec 8) ) ) +(assert (bvult (ite (bvult (_ bv0 1) ((_ extract 0 0) (select arr1 (_ bv0 32)))) (concat (select arr0 (_ bv7 32)) (select arr0 (_ bv6 32)) (select arr0 (_ bv5 32)) (select arr0 (_ bv4 32)) (select arr0 (_ bv3 32)) (select arr0 (_ bv2 32)) (select arr0 (_ bv1 32)) (select arr0 (_ bv0 32))) (concat (_ bv0 57) ((_ extract 7 1) (select arr2 (_ bv0 32))))) (_ bv1 64) )) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/Makefile.am b/test/regress/regress1/nl/Makefile.am index a7e4c1411..bafaf665a 100644 --- a/test/regress/regress1/nl/Makefile.am +++ b/test/regress/regress1/nl/Makefile.am @@ -17,8 +17,53 @@ endif # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" TESTS = \ - siegel-nl-bases.smt2 \ - mirko-050417.smt2 + mirko-050417.smt2 \ + arrowsmith-050317.smt2 \ + bug698.smt2 \ + dist-big.smt2 \ + dumortier_llibre_artes_ex_5_13.transcendental.k2.smt2 \ + exp-4.5-lt.smt2 \ + metitarski_3_4_2e.smt2 \ + metitarski-3-4.smt2 \ + nl-help-unsat-quant.smt2 \ + poly-1025.smt2 \ + quant-nl.smt2 \ + red-exp.smt2 \ + rewriting-sums.smt2 \ + simple-mono.smt2 \ + sin1-sat.smt2 \ + sin-compare.smt2 \ + sin-compare-across-phase.smt2 \ + sqrt-problem-1.smt2 \ + sugar-ident-2.smt2 \ + sugar-ident-3.smt2 \ + tan-rewrite2.smt2 \ + bad-050217.smt2 \ + coeff-unsat-base.smt2 \ + coeff-unsat.smt2 \ + combine.smt2 \ + cos-bound.smt2 \ + cos1-tc.smt2 \ + disj-eval.smt2 \ + div-mod-partial.smt2 \ + exp_monotone.smt2 \ + exp1-lb.smt2 \ + metitarski-1025.smt2 \ + NAVIGATION2.smt2 \ + nl-unk-quant.smt2 \ + ones.smt2 \ + shifting.smt2 \ + shifting2.smt2 \ + simple-mono-unsat.smt2 \ + sin-init-tangents.smt2 \ + sin-sign.smt2 \ + sin-sym2.smt2 \ + sin1-lb.smt2 \ + sin1-ub.smt2 \ + sin2-lb.smt2 \ + sin2-ub.smt2 \ + sugar-ident.smt2 \ + zero-subset.smt2 EXTRA_DIST = $(TESTS) diff --git a/test/regress/regress1/nl/NAVIGATION2.smt2 b/test/regress/regress1/nl/NAVIGATION2.smt2 new file mode 100644 index 000000000..445b8a21e --- /dev/null +++ b/test/regress/regress1/nl/NAVIGATION2.smt2 @@ -0,0 +1,23 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :source |printed by MathSAT|) +(declare-fun X () Real) + +(assert (let ((.def_44 (* (- (/ 11 10)) X))) +(let ((.def_45 (exp .def_44))) +(let ((.def_50 (* 250 .def_45))) +(let ((.def_40 (* (- (/ 13 10)) X))) +(let ((.def_41 (exp .def_40))) +(let ((.def_52 (* 173 .def_41))) +(let ((.def_53 (+ .def_52 .def_50))) +(let ((.def_54 (* 250 X))) +(let ((.def_55 (+ .def_54 .def_53))) +(let ((.def_56 (<= .def_55 (/ 595 2)))) +(let ((.def_57 (not .def_56))) +(let ((.def_31 (<= 0 X))) +(let ((.def_32 (not .def_31))) +(let ((.def_58 (or .def_32 .def_57))) +(let ((.def_59 (not .def_58))) +.def_59)))))))))))))))) +(check-sat) diff --git a/test/regress/regress1/nl/arrowsmith-050317.smt2 b/test/regress/regress1/nl/arrowsmith-050317.smt2 new file mode 100644 index 000000000..04b06e1f5 --- /dev/null +++ b/test/regress/regress1/nl/arrowsmith-050317.smt2 @@ -0,0 +1,95 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun time__AT0@0 () Real) +(declare-fun instance.location.0__AT0@0 () Bool) +(declare-fun instance.y__AT0@0 () Real) +(declare-fun instance.x__AT0@0 () Real) +(declare-fun instance.location.0__AT0@4 () Bool) +(declare-fun event_is_timed__AT0@1 () Bool) +(declare-fun event_is_timed__AT0@0 () Bool) +(declare-fun instance.location.0__AT0@1 () Bool) +(declare-fun instance.x__AT0@1 () Real) +(declare-fun instance.y__AT0@1 () Real) +(declare-fun instance.EVENT.0__AT0@0 () Bool) +(declare-fun instance.EVENT.1__AT0@0 () Bool) +(declare-fun time__AT0@1 () Real) +(declare-fun event_is_timed__AT0@3 () Bool) +(declare-fun instance.location.0__AT0@3 () Bool) +(declare-fun instance.x__AT0@3 () Real) +(declare-fun instance.y__AT0@3 () Real) +(declare-fun instance.EVENT.0__AT0@2 () Bool) +(declare-fun instance.EVENT.1__AT0@2 () Bool) +(declare-fun time__AT0@3 () Real) +(declare-fun event_is_timed__AT0@2 () Bool) +(declare-fun instance.location.0__AT0@2 () Bool) +(declare-fun instance.x__AT0@2 () Real) +(declare-fun instance.y__AT0@2 () Real) +(declare-fun instance.EVENT.0__AT0@1 () Bool) +(declare-fun instance.EVENT.1__AT0@1 () Bool) +(declare-fun time__AT0@2 () Real) +(declare-fun event_is_timed__AT0@4 () Bool) +(declare-fun instance.x__AT0@4 () Real) +(declare-fun instance.y__AT0@4 () Real) +(declare-fun instance.EVENT.0__AT0@3 () Bool) +(declare-fun instance.EVENT.1__AT0@3 () Bool) +(declare-fun time__AT0@4 () Real) +(assert (let ((.def_0 (not instance.EVENT.1__AT0@3))) (let ((.def_1 (not instance.EVENT.0__AT0@3))) (let ((.def_2 (or .def_1 .def_0))) (let ((.def_3 (= event_is_timed__AT0@3 instance.EVENT.1__AT0@3))) (let ((.def_4 (<= time__AT0@3 +time__AT0@4))) (let ((.def_5 (or .def_0 .def_4))) (let ((.def_6 (and .def_5 .def_3))) (let ((.def_7 (= time__AT0@3 time__AT0@4))) (let ((.def_8 (or instance.EVENT.1__AT0@3 .def_7))) (let ((.def_9 (and .def_8 .def_6))) (let +((.def_10 (<= instance.x__AT0@3 0.0))) (let ((.def_11 (not .def_10))) (let ((.def_12 (not instance.location.0__AT0@3))) (let ((.def_13 (and .def_12 .def_11))) (let ((.def_14 (and instance.location.0__AT0@4 .def_13))) (let ((.def_15 +(= instance.x__AT0@3 instance.x__AT0@4))) (let ((.def_16 (and .def_15 .def_14))) (let ((.def_17 (= instance.y__AT0@3 instance.y__AT0@4))) (let ((.def_18 (and .def_17 .def_16))) (let ((.def_19 (<= instance.y__AT0@3 0.0))) (let +((.def_20 (and .def_12 .def_19))) (let ((.def_21 (and instance.location.0__AT0@4 .def_20))) (let ((.def_22 (and .def_15 .def_21))) (let ((.def_23 (and .def_17 .def_22))) (let ((.def_24 (or .def_23 .def_18))) (let ((.def_25 (and +.def_7 .def_24))) (let ((.def_26 (or instance.EVENT.1__AT0@3 .def_25))) (let ((.def_27 (not .def_7))) (let ((.def_28 (and .def_15 .def_17))) (let ((.def_29 (or .def_28 .def_27))) (let ((.def_30 (and .def_28 .def_29))) (let +((.def_31 (or .def_30 .def_12))) (let ((.def_32 (* (- 1.0) time__AT0@3))) (let ((.def_33 (+ .def_32 time__AT0@4))) (let ((.def_34 (exp .def_33))) (let ((.def_35 (* instance.x__AT0@3 .def_34))) (let ((.def_36 (= instance.x__AT0@4 +.def_35))) (let ((.def_37 (* 2.0 instance.x__AT0@4))) (let ((.def_38 (* instance.y__AT0@4 .def_37))) (let ((.def_39 (* (- 1.0) .def_38))) (let ((.def_40 (* 2.0 instance.x__AT0@3))) (let ((.def_41 (* instance.y__AT0@3 .def_40))) +(let ((.def_42 (* (- 1.0) .def_41))) (let ((.def_43 (+ instance.y__AT0@3 .def_42))) (let ((.def_44 (* .def_43 .def_34))) (let ((.def_45 (* (- 1.0) .def_44))) (let ((.def_46 (+ .def_45 .def_39))) (let ((.def_47 (+ instance.y__AT0@4 +.def_46))) (let ((.def_48 (= .def_47 0.0))) (let ((.def_49 (and .def_48 .def_36))) (let ((.def_50 (and .def_49 .def_29))) (let ((.def_51 (or instance.location.0__AT0@3 .def_50))) (let ((.def_52 (and .def_51 .def_31))) (let +((.def_53 (and .def_52 .def_4))) (let ((.def_54 (= instance.location.0__AT0@4 instance.location.0__AT0@3))) (let ((.def_55 (and .def_54 .def_53))) (let ((.def_56 (or .def_0 .def_55))) (let ((.def_57 (and .def_56 .def_26))) (let +((.def_58 (and .def_1 .def_0))) (let ((.def_59 (or .def_58 .def_57))) (let ((.def_60 (and .def_59 .def_9))) (let ((.def_61 (not .def_58))) (let ((.def_62 (and .def_54 .def_15))) (let ((.def_63 (and .def_62 .def_17))) (let ((.def_64 +(or .def_63 .def_61))) (let ((.def_65 (and .def_64 .def_60))) (let ((.def_66 (not event_is_timed__AT0@3))) (let ((.def_67 (= event_is_timed__AT0@4 .def_66))) (let ((.def_68 (and .def_67 .def_65))) (let ((.def_69 (and .def_68 +.def_2))) (let ((.def_70 (not instance.EVENT.1__AT0@2))) (let ((.def_71 (not instance.EVENT.0__AT0@2))) (let ((.def_72 (or .def_71 .def_70))) (let ((.def_73 (= event_is_timed__AT0@2 instance.EVENT.1__AT0@2))) (let ((.def_74 (<= +time__AT0@2 time__AT0@3))) (let ((.def_75 (or .def_70 .def_74))) (let ((.def_76 (and .def_75 .def_73))) (let ((.def_77 (= time__AT0@2 time__AT0@3))) (let ((.def_78 (or instance.EVENT.1__AT0@2 .def_77))) (let ((.def_79 (and .def_78 +.def_76))) (let ((.def_80 (<= instance.x__AT0@2 0.0))) (let ((.def_81 (not .def_80))) (let ((.def_82 (not instance.location.0__AT0@2))) (let ((.def_83 (and .def_82 .def_81))) (let ((.def_84 (and instance.location.0__AT0@3 +.def_83))) (let ((.def_85 (= instance.x__AT0@2 instance.x__AT0@3))) (let ((.def_86 (and .def_85 .def_84))) (let ((.def_87 (= instance.y__AT0@2 instance.y__AT0@3))) (let ((.def_88 (and .def_87 .def_86))) (let ((.def_89 (<= +instance.y__AT0@2 0.0))) (let ((.def_90 (and .def_82 .def_89))) (let ((.def_91 (and instance.location.0__AT0@3 .def_90))) (let ((.def_92 (and .def_85 .def_91))) (let ((.def_93 (and .def_87 .def_92))) (let ((.def_94 (or .def_93 +.def_88))) (let ((.def_95 (and .def_77 .def_94))) (let ((.def_96 (or instance.EVENT.1__AT0@2 .def_95))) (let ((.def_97 (not .def_77))) (let ((.def_98 (and .def_85 .def_87))) (let ((.def_99 (or .def_98 .def_97))) (let ((.def_100 +(and .def_98 .def_99))) (let ((.def_101 (or .def_100 .def_82))) (let ((.def_102 (* (- 1.0) time__AT0@2))) (let ((.def_103 (+ .def_102 time__AT0@3))) (let ((.def_104 (exp .def_103))) (let ((.def_105 (* instance.x__AT0@2 .def_104))) +(let ((.def_106 (= instance.x__AT0@3 .def_105))) (let ((.def_107 (* 2.0 instance.x__AT0@2))) (let ((.def_108 (* instance.y__AT0@2 .def_107))) (let ((.def_109 (* (- 1.0) .def_108))) (let ((.def_110 (+ instance.y__AT0@2 .def_109))) +(let ((.def_111 (* .def_110 .def_104))) (let ((.def_112 (* (- 1.0) .def_111))) (let ((.def_113 (+ .def_112 .def_42))) (let ((.def_114 (+ instance.y__AT0@3 .def_113))) (let ((.def_115 (= .def_114 0.0))) (let ((.def_116 (and .def_115 +.def_106))) (let ((.def_117 (and .def_116 .def_99))) (let ((.def_118 (or instance.location.0__AT0@2 .def_117))) (let ((.def_119 (and .def_118 .def_101))) (let ((.def_120 (and .def_119 .def_74))) (let ((.def_121 (= +instance.location.0__AT0@2 instance.location.0__AT0@3))) (let ((.def_122 (and .def_121 .def_120))) (let ((.def_123 (or .def_70 .def_122))) (let ((.def_124 (and .def_123 .def_96))) (let ((.def_125 (and .def_71 .def_70))) (let +((.def_126 (or .def_125 .def_124))) (let ((.def_127 (and .def_126 .def_79))) (let ((.def_128 (not .def_125))) (let ((.def_129 (and .def_121 .def_85))) (let ((.def_130 (and .def_129 .def_87))) (let ((.def_131 (or .def_130 +.def_128))) (let ((.def_132 (and .def_131 .def_127))) (let ((.def_133 (not event_is_timed__AT0@2))) (let ((.def_134 (= event_is_timed__AT0@3 .def_133))) (let ((.def_135 (and .def_134 .def_132))) (let ((.def_136 (and .def_135 +.def_72))) (let ((.def_137 (not instance.EVENT.1__AT0@1))) (let ((.def_138 (not instance.EVENT.0__AT0@1))) (let ((.def_139 (or .def_138 .def_137))) (let ((.def_140 (= event_is_timed__AT0@1 instance.EVENT.1__AT0@1))) (let ((.def_141 +(<= time__AT0@1 time__AT0@2))) (let ((.def_142 (or .def_137 .def_141))) (let ((.def_143 (and .def_142 .def_140))) (let ((.def_144 (= time__AT0@1 time__AT0@2))) (let ((.def_145 (or instance.EVENT.1__AT0@1 .def_144))) (let ((.def_146 +(and .def_145 .def_143))) (let ((.def_147 (<= instance.x__AT0@1 0.0))) (let ((.def_148 (not .def_147))) (let ((.def_149 (not instance.location.0__AT0@1))) (let ((.def_150 (and .def_149 .def_148))) (let ((.def_151 (and +instance.location.0__AT0@2 .def_150))) (let ((.def_152 (= instance.x__AT0@1 instance.x__AT0@2))) (let ((.def_153 (and .def_152 .def_151))) (let ((.def_154 (= instance.y__AT0@1 instance.y__AT0@2))) (let ((.def_155 (and .def_154 +.def_153))) (let ((.def_156 (<= instance.y__AT0@1 0.0))) (let ((.def_157 (and .def_149 .def_156))) (let ((.def_158 (and instance.location.0__AT0@2 .def_157))) (let ((.def_159 (and .def_152 .def_158))) (let ((.def_160 (and .def_154 +.def_159))) (let ((.def_161 (or .def_160 .def_155))) (let ((.def_162 (and .def_144 .def_161))) (let ((.def_163 (or instance.EVENT.1__AT0@1 .def_162))) (let ((.def_164 (not .def_144))) (let ((.def_165 (and .def_152 .def_154))) (let +((.def_166 (or .def_165 .def_164))) (let ((.def_167 (and .def_165 .def_166))) (let ((.def_168 (or .def_167 .def_149))) (let ((.def_169 (* (- 1.0) time__AT0@1))) (let ((.def_170 (+ .def_169 time__AT0@2))) (let ((.def_171 (exp +.def_170))) (let ((.def_172 (* instance.x__AT0@1 .def_171))) (let ((.def_173 (= instance.x__AT0@2 .def_172))) (let ((.def_174 (* 2.0 instance.x__AT0@1))) (let ((.def_175 (* instance.y__AT0@1 .def_174))) (let ((.def_176 (* (- 1.0) +.def_175))) (let ((.def_177 (+ instance.y__AT0@1 .def_176))) (let ((.def_178 (* .def_177 .def_171))) (let ((.def_179 (* (- 1.0) .def_178))) (let ((.def_180 (+ .def_179 .def_109))) (let ((.def_181 (+ instance.y__AT0@2 .def_180))) +(let ((.def_182 (= .def_181 0.0))) (let ((.def_183 (and .def_182 .def_173))) (let ((.def_184 (and .def_183 .def_166))) (let ((.def_185 (or instance.location.0__AT0@1 .def_184))) (let ((.def_186 (and .def_185 .def_168))) (let +((.def_187 (and .def_186 .def_141))) (let ((.def_188 (= instance.location.0__AT0@1 instance.location.0__AT0@2))) (let ((.def_189 (and .def_188 .def_187))) (let ((.def_190 (or .def_137 .def_189))) (let ((.def_191 (and .def_190 +.def_163))) (let ((.def_192 (and .def_138 .def_137))) (let ((.def_193 (or .def_192 .def_191))) (let ((.def_194 (and .def_193 .def_146))) (let ((.def_195 (not .def_192))) (let ((.def_196 (and .def_188 .def_152))) (let ((.def_197 +(and .def_196 .def_154))) (let ((.def_198 (or .def_197 .def_195))) (let ((.def_199 (and .def_198 .def_194))) (let ((.def_200 (not event_is_timed__AT0@1))) (let ((.def_201 (= event_is_timed__AT0@2 .def_200))) (let ((.def_202 (and +.def_201 .def_199))) (let ((.def_203 (and .def_202 .def_139))) (let ((.def_204 (not instance.EVENT.1__AT0@0))) (let ((.def_205 (not instance.EVENT.0__AT0@0))) (let ((.def_206 (or .def_205 .def_204))) (let ((.def_207 (= +event_is_timed__AT0@0 instance.EVENT.1__AT0@0))) (let ((.def_208 (<= time__AT0@0 time__AT0@1))) (let ((.def_209 (or .def_204 .def_208))) (let ((.def_210 (and .def_209 .def_207))) (let ((.def_211 (= time__AT0@0 time__AT0@1))) (let +((.def_212 (or instance.EVENT.1__AT0@0 .def_211))) (let ((.def_213 (and .def_212 .def_210))) (let ((.def_214 (<= instance.x__AT0@0 0.0))) (let ((.def_215 (not .def_214))) (let ((.def_216 (not instance.location.0__AT0@0))) (let +((.def_217 (and .def_216 .def_215))) (let ((.def_218 (and instance.location.0__AT0@1 .def_217))) (let ((.def_219 (= instance.x__AT0@0 instance.x__AT0@1))) (let ((.def_220 (and .def_219 .def_218))) (let ((.def_221 (= +instance.y__AT0@0 instance.y__AT0@1))) (let ((.def_222 (and .def_221 .def_220))) (let ((.def_223 (<= instance.y__AT0@0 0.0))) (let ((.def_224 (and .def_216 .def_223))) (let ((.def_225 (and instance.location.0__AT0@1 .def_224))) +(let ((.def_226 (and .def_219 .def_225))) (let ((.def_227 (and .def_221 .def_226))) (let ((.def_228 (or .def_227 .def_222))) (let ((.def_229 (and .def_211 .def_228))) (let ((.def_230 (or instance.EVENT.1__AT0@0 .def_229))) (let +((.def_231 (not .def_211))) (let ((.def_232 (and .def_219 .def_221))) (let ((.def_233 (or .def_232 .def_231))) (let ((.def_234 (and .def_232 .def_233))) (let ((.def_235 (or .def_216 .def_234))) (let ((.def_236 (* (- 1.0) +time__AT0@0))) (let ((.def_237 (+ .def_236 time__AT0@1))) (let ((.def_238 (exp .def_237))) (let ((.def_239 (* instance.x__AT0@0 .def_238))) (let ((.def_240 (= instance.x__AT0@1 .def_239))) (let ((.def_241 (* 2.0 +instance.x__AT0@0))) (let ((.def_242 (* instance.y__AT0@0 .def_241))) (let ((.def_243 (* (- 1.0) .def_242))) (let ((.def_244 (+ instance.y__AT0@0 .def_243))) (let ((.def_245 (* .def_244 .def_238))) (let ((.def_246 (* (- 1.0) +.def_245))) (let ((.def_247 (+ .def_246 .def_176))) (let ((.def_248 (+ instance.y__AT0@1 .def_247))) (let ((.def_249 (= .def_248 0.0))) (let ((.def_250 (and .def_249 .def_240))) (let ((.def_251 (and .def_250 .def_233))) (let +((.def_252 (or instance.location.0__AT0@0 .def_251))) (let ((.def_253 (and .def_252 .def_235))) (let ((.def_254 (and .def_253 .def_208))) (let ((.def_255 (= instance.location.0__AT0@0 instance.location.0__AT0@1))) (let ((.def_256 +(and .def_255 .def_254))) (let ((.def_257 (or .def_204 .def_256))) (let ((.def_258 (and .def_257 .def_230))) (let ((.def_259 (and .def_205 .def_204))) (let ((.def_260 (or .def_259 .def_258))) (let ((.def_261 (and .def_260 +.def_213))) (let ((.def_262 (not .def_259))) (let ((.def_263 (and .def_255 .def_219))) (let ((.def_264 (and .def_263 .def_221))) (let ((.def_265 (or .def_264 .def_262))) (let ((.def_266 (and .def_265 .def_261))) (let ((.def_267 +(not event_is_timed__AT0@0))) (let ((.def_268 (= event_is_timed__AT0@1 .def_267))) (let ((.def_269 (and .def_268 .def_266))) (let ((.def_270 (and .def_269 .def_206))) (let ((.def_271 (= instance.x__AT0@0 (- 1.0)))) (let ((.def_272 +(= instance.y__AT0@0 1.0))) (let ((.def_273 (and .def_272 .def_271))) (let ((.def_274 (and .def_216 .def_273))) (let ((.def_275 (= time__AT0@0 0.0))) (let ((.def_276 (and .def_275 .def_274))) (let ((.def_277 (and .def_276 .def_270 +.def_203 .def_136 .def_69 instance.location.0__AT0@4))) +.def_277))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/bad-050217.smt2 b/test/regress/regress1/nl/bad-050217.smt2 new file mode 100644 index 000000000..3b9310748 --- /dev/null +++ b/test/regress/regress1/nl/bad-050217.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status sat) +(declare-fun time__AT0@0 () Real) +(declare-fun instance.y__AT0@0 () Real) +(declare-fun instance.x__AT0@0 () Real) +(declare-fun instance.x__AT0@1 () Real) +(declare-fun event_is_timed__AT0@1 () Bool) +(declare-fun event_is_timed__AT0@0 () Bool) +(declare-fun instance.EVENT.0__AT0@0 () Bool) +(declare-fun instance.EVENT.1__AT0@0 () Bool) +(declare-fun instance.y__AT0@1 () Real) +(declare-fun time__AT0@1 () Real) +(assert (let ((.def_0 (<= 0.0 instance.x__AT0@1))) (let ((.def_1 (not .def_0))) (let ((.def_2 (not instance.EVENT.1__AT0@0))) (let ((.def_3 (not instance.EVENT.0__AT0@0))) (let ((.def_4 (or .def_3 .def_2))) (let ((.def_5 (= event_is_timed__AT0@0 instance.EVENT.1__AT0@0))) (let ((.def_6 (<= time__AT0@0 time__AT0@1))) (let ((.def_7 (or .def_2 .def_6))) (let ((.def_8 (and .def_7 .def_5))) (let ((.def_9 (= time__AT0@0 time__AT0@1))) (let ((.def_10 (or instance.EVENT.1__AT0@0 .def_9))) (let ((.def_11 (and .def_10 .def_8))) (let ((.def_12 (* (- 1.0) instance.y__AT0@0))) (let ((.def_13 (+ instance.x__AT0@0 .def_12))) (let ((.def_14 (* (- 1.0) time__AT0@0))) (let ((.def_15 (+ .def_14 time__AT0@1))) (let ((.def_16 (exp .def_15))) (let ((.def_17 (* .def_16 .def_13))) (let ((.def_18 (* (- 1.0) .def_17))) (let ((.def_19 (* (- 1.0) instance.y__AT0@1))) (let ((.def_20 (+ .def_19 .def_18))) (let ((.def_21 (+ instance.x__AT0@1 .def_20))) (let ((.def_22 (= .def_21 0.0))) (let ((.def_23 (+ instance.y__AT0@0 instance.x__AT0@0))) (let ((.def_24 (* .def_23 .def_16))) (let ((.def_25 (* (- 1.0) .def_24))) (let ((.def_26 (+ instance.y__AT0@1 .def_25))) (let ((.def_27 (+ instance.x__AT0@1 .def_26))) (let ((.def_28 (= .def_27 0.0))) (let ((.def_29 (and .def_28 .def_22))) (let ((.def_30 (not .def_9))) (let ((.def_31 (= instance.x__AT0@0 instance.x__AT0@1))) (let ((.def_32 (= instance.y__AT0@0 instance.y__AT0@1))) (let ((.def_33 (and .def_32 .def_31))) (let ((.def_34 (or .def_33 .def_30))) (let ((.def_35 (and .def_34 .def_29))) (let ((.def_36 (and .def_35 .def_6))) (let ((.def_37 (or .def_2 .def_36))) (let ((.def_38 (and .def_37 .def_10))) (let ((.def_39 (and .def_3 .def_2))) (let ((.def_40 (or .def_39 .def_38))) (let ((.def_41 (and .def_40 .def_11))) (let ((.def_42 (not .def_39))) (let ((.def_43 (or .def_42 .def_33))) (let ((.def_44 (and .def_43 .def_41))) (let ((.def_45 (not event_is_timed__AT0@0))) (let ((.def_46 (= event_is_timed__AT0@1 .def_45))) (let ((.def_47 (and .def_46 .def_44))) (let ((.def_48 (and .def_47 .def_4))) (let ((.def_49 (= instance.x__AT0@0 1.0))) (let ((.def_50 (= instance.y__AT0@0 0.0))) (let ((.def_51 (and .def_50 .def_49))) (let ((.def_52 (= time__AT0@0 0.0))) (let ((.def_53 (and .def_52 .def_51))) (let ((.def_54 (and .def_53 .def_48 .def_1))) .def_54)))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/bug698.smt2 b/test/regress/regress1/nl/bug698.smt2 new file mode 100644 index 000000000..ffb1eead2 --- /dev/null +++ b/test/regress/regress1/nl/bug698.smt2 @@ -0,0 +1,33 @@ +; COMMAND-LINE: --incremental --nl-ext --fmf-fun-rlv --no-check-models +(set-logic UFNIA) +(set-info :smt-lib-version 2.5) + +; EXPECT: sat +(declare-fun fixedAdd() Int) +(assert (= fixedAdd (+ 2 (+ 2 (+ 2 0))))) +(check-sat) + +(define-fun-rec $$add$$ ((a Int)(b Int)) Int + (ite (= b 0) + 0 + (+ a ($$add$$ a (- b 1))))) + +; EXPECT: sat +(declare-fun variableAdd() Int) +(assert (= variableAdd ($$add$$ 2 3))) +(check-sat) + +; EXPECT: sat +(declare-fun fixedTimes() Int) +(assert (= fixedTimes (* 2 (* 2 (* 2 1))))) +(check-sat) + +; EXPECT: sat +(define-fun-rec $$pow$$ ((a Int)(b Int)) Int + (ite (= b 0) + 1 + (* a ($$pow$$ a (- b 1))))) + +(declare-fun variableTimes() Int) +(assert (= variableTimes ($$pow$$ 2 3))) +(check-sat) diff --git a/test/regress/regress1/nl/coeff-unsat-base.smt2 b/test/regress/regress1/nl/coeff-unsat-base.smt2 new file mode 100644 index 000000000..d56421bf9 --- /dev/null +++ b/test/regress/regress1/nl/coeff-unsat-base.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) + +(assert (> a 0)) +(assert (> b 0)) + +(assert (>= a (* 3 b))) + +(assert (< (* a a) (* 3 a b))) + +(check-sat) diff --git a/test/regress/regress1/nl/coeff-unsat.smt2 b/test/regress/regress1/nl/coeff-unsat.smt2 new file mode 100644 index 000000000..f86d08fe7 --- /dev/null +++ b/test/regress/regress1/nl/coeff-unsat.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) + +(assert (> a 0)) +(assert (> b 0)) + +(assert (>= a (* 3 b))) + +(assert (< (* a a) (* 8 b b))) + +(check-sat) diff --git a/test/regress/regress1/nl/combine.smt2 b/test/regress/regress1/nl/combine.smt2 new file mode 100644 index 000000000..9f7e7a548 --- /dev/null +++ b/test/regress/regress1/nl/combine.smt2 @@ -0,0 +1,13 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(assert (> c 1)) +(assert (> (* a b) 1)) + +(assert (< (* a b c) 1)) + +(check-sat) diff --git a/test/regress/regress1/nl/cos-bound.smt2 b/test/regress/regress1/nl/cos-bound.smt2 new file mode 100644 index 000000000..e19260d63 --- /dev/null +++ b/test/regress/regress1/nl/cos-bound.smt2 @@ -0,0 +1,6 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_UFNRA) +(declare-fun x () Real) +(assert (> (cos x) 1.0)) +(check-sat) diff --git a/test/regress/regress1/nl/cos1-tc.smt2 b/test/regress/regress1/nl/cos1-tc.smt2 new file mode 100644 index 000000000..7ddae1453 --- /dev/null +++ b/test/regress/regress1/nl/cos1-tc.smt2 @@ -0,0 +1,8 @@ +; COMMAND-LINE: --nl-ext --no-nl-ext-tf-inc-prec +; EXPECT: unknown +(set-logic UFNRA) +(declare-fun f (Real) Real) + +(assert (= (f 0.0) (cos 1))) + +(check-sat) diff --git a/test/regress/regress1/nl/disj-eval.smt2 b/test/regress/regress1/nl/disj-eval.smt2 new file mode 100644 index 000000000..ac8cfc937 --- /dev/null +++ b/test/regress/regress1/nl/disj-eval.smt2 @@ -0,0 +1,14 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: sat +(set-logic QF_NIA) +(set-info :status sat) +(declare-fun x () Int) +(declare-fun y () Int) + +(assert (or (= x 5) (= x 7) (= x 9) (= x 27) (= x 10))) +(assert (or (= y 0) (= y 1) (= y 9) (= y 8))) + + +(assert (= (* x x) (* y y y))) + +(check-sat) diff --git a/test/regress/regress1/nl/dist-big.smt2 b/test/regress/regress1/nl/dist-big.smt2 new file mode 100644 index 000000000..53c9c3f1d --- /dev/null +++ b/test/regress/regress1/nl/dist-big.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status sat) +(declare-fun v1 () Real) +(declare-fun v2 () Real) +(declare-fun v3 () Real) +(declare-fun v4 () Real) +(declare-fun v5 () Real) +(declare-fun v6 () Real) +(declare-fun v7 () Real) +(declare-fun v8 () Real) + +(assert (= (* (+ v1 v2 v3 v4 v5 v6 v7 v8) (+ v1 v2 v3 v4 v5 v6 v7 v8) (+ v1 v2 v3 v4 v5 v6 v7 v8) (+ v1 v2 v3 v4 v5 v6 v7 v8)) 0)) + +(check-sat) diff --git a/test/regress/regress1/nl/div-mod-partial.smt2 b/test/regress/regress1/nl/div-mod-partial.smt2 new file mode 100644 index 000000000..fa75ee594 --- /dev/null +++ b/test/regress/regress1/nl/div-mod-partial.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --nl-ext --nl-ext-tplanes +; EXPECT: sat +(set-logic QF_UFNIA) +(set-info :status sat) +(declare-fun x () Int) +(declare-fun y () Int) +(assert (not (= y 0))) +; should be SAT if the partial functions for div and mod are different +(assert (not (= (- y (* (div y x) x)) (mod y x)))) +(check-sat) diff --git a/test/regress/regress1/nl/dumortier_llibre_artes_ex_5_13.transcendental.k2.smt2 b/test/regress/regress1/nl/dumortier_llibre_artes_ex_5_13.transcendental.k2.smt2 new file mode 100644 index 000000000..5dce6ddca --- /dev/null +++ b/test/regress/regress1/nl/dumortier_llibre_artes_ex_5_13.transcendental.k2.smt2 @@ -0,0 +1,22 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: sat +(set-logic QF_NRA) +(declare-fun time__AT0@0 () Real) +(declare-fun instance.y__AT0@0 () Real) +(declare-fun instance.x__AT0@0 () Real) +(declare-fun instance.y__AT0@2 () Real) +(declare-fun event_is_timed__AT0@2 () Bool) +(declare-fun instance.EVENT.0__AT0@1 () Bool) +(declare-fun instance.EVENT.1__AT0@1 () Bool) +(declare-fun event_is_timed__AT0@1 () Bool) +(declare-fun event_is_timed__AT0@0 () Bool) +(declare-fun instance.EVENT.0__AT0@0 () Bool) +(declare-fun instance.EVENT.1__AT0@0 () Bool) +(declare-fun instance.y__AT0@1 () Real) +(declare-fun instance.x__AT0@1 () Real) +(declare-fun time__AT0@1 () Real) +(declare-fun instance.x__AT0@2 () Real) +(declare-fun time__AT0@2 () Real) +(assert (let ((.def_0 (<= instance.y__AT0@2 2.0))) (let ((.def_1 (not .def_0))) (let ((.def_2 (not instance.EVENT.1__AT0@1))) (let ((.def_3 (not instance.EVENT.0__AT0@1))) (let ((.def_4 (or .def_3 .def_2))) (let ((.def_5 (= event_is_timed__AT0@1 instance.EVENT.1__AT0@1))) (let ((.def_6 (<= time__AT0@1 time__AT0@2))) (let ((.def_7 (or .def_2 .def_6))) (let ((.def_8 (and .def_7 .def_5))) (let ((.def_9 (= time__AT0@1 time__AT0@2))) (let ((.def_10 (or instance.EVENT.1__AT0@1 .def_9))) (let ((.def_11 (and .def_10 .def_8))) (let ((.def_12 (* (- 1.0) time__AT0@1))) (let ((.def_13 (+ .def_12 time__AT0@2))) (let ((.def_14 (exp .def_13))) (let ((.def_15 (* instance.y__AT0@1 .def_14))) (let ((.def_16 (= instance.y__AT0@2 .def_15))) (let ((.def_17 (* 970143.0 instance.x__AT0@2))) (let ((.def_18 (* (- 970143.0) instance.x__AT0@1))) (let ((.def_19 (+ .def_18 .def_17))) (let ((.def_20 (* (- 242536.0) instance.y__AT0@1))) (let ((.def_21 (+ .def_20 .def_19))) (let ((.def_22 (* 242536.0 instance.y__AT0@2))) (let ((.def_23 (+ .def_22 .def_21))) (let ((.def_24 (= .def_23 0.0))) (let ((.def_25 (and .def_24 .def_16))) (let ((.def_26 (not .def_9))) (let ((.def_27 (= instance.x__AT0@1 instance.x__AT0@2))) (let ((.def_28 (= instance.y__AT0@2 instance.y__AT0@1))) (let ((.def_29 (and .def_28 .def_27))) (let ((.def_30 (or .def_29 .def_26))) (let ((.def_31 (and .def_30 .def_25))) (let ((.def_32 (and .def_31 .def_6))) (let ((.def_33 (or .def_2 .def_32))) (let ((.def_34 (and .def_33 .def_10))) (let ((.def_35 (and .def_3 .def_2))) (let ((.def_36 (or .def_35 .def_34))) (let ((.def_37 (and .def_36 .def_11))) (let ((.def_38 (not .def_35))) (let ((.def_39 (or .def_38 .def_29))) (let ((.def_40 (and .def_39 .def_37))) (let ((.def_41 (not event_is_timed__AT0@1))) (let ((.def_42 (= event_is_timed__AT0@2 .def_41))) (let ((.def_43 (and .def_42 .def_40))) (let ((.def_44 (and .def_43 .def_4))) (let ((.def_45 (not instance.EVENT.1__AT0@0))) (let ((.def_46 (not instance.EVENT.0__AT0@0))) (let ((.def_47 (or .def_46 .def_45))) (let ((.def_48 (= event_is_timed__AT0@0 instance.EVENT.1__AT0@0))) (let ((.def_49 (<= time__AT0@0 time__AT0@1))) (let ((.def_50 (or .def_45 .def_49))) (let ((.def_51 (and .def_50 .def_48))) (let ((.def_52 (= time__AT0@0 time__AT0@1))) (let ((.def_53 (or instance.EVENT.1__AT0@0 .def_52))) (let ((.def_54 (and .def_53 .def_51))) (let ((.def_55 (* (- 1.0) time__AT0@0))) (let ((.def_56 (+ .def_55 time__AT0@1))) (let ((.def_57 (exp .def_56))) (let ((.def_58 (* instance.y__AT0@0 .def_57))) (let ((.def_59 (= instance.y__AT0@1 .def_58))) (let ((.def_60 (+ .def_20 .def_18))) (let ((.def_61 (* 970143.0 instance.x__AT0@0))) (let ((.def_62 (+ .def_61 .def_60))) (let ((.def_63 (* 242536.0 instance.y__AT0@0))) (let ((.def_64 (+ .def_63 .def_62))) (let ((.def_65 (= .def_64 0.0))) (let ((.def_66 (and .def_65 .def_59))) (let ((.def_67 (not .def_52))) (let ((.def_68 (= instance.x__AT0@0 instance.x__AT0@1))) (let ((.def_69 (= instance.y__AT0@0 instance.y__AT0@1))) (let ((.def_70 (and .def_69 .def_68))) (let ((.def_71 (or .def_70 .def_67))) (let ((.def_72 (and .def_71 .def_66))) (let ((.def_73 (and .def_72 .def_49))) (let ((.def_74 (or .def_45 .def_73))) (let ((.def_75 (and .def_74 .def_53))) (let ((.def_76 (and .def_46 .def_45))) (let ((.def_77 (or .def_76 .def_75))) (let ((.def_78 (and .def_77 .def_54))) (let ((.def_79 (not .def_76))) (let ((.def_80 (or .def_79 .def_70))) (let ((.def_81 (and .def_80 .def_78))) (let ((.def_82 (not event_is_timed__AT0@0))) (let ((.def_83 (= event_is_timed__AT0@1 .def_82))) (let ((.def_84 (and .def_83 .def_81))) (let ((.def_85 (and .def_84 .def_47))) (let ((.def_86 (<= instance.x__AT0@0 (- (/ 1 2))))) (let ((.def_87 (not .def_86))) (let ((.def_88 (<= 0.0 instance.x__AT0@0))) (let ((.def_89 (not .def_88))) (let ((.def_90 (and .def_89 .def_87))) (let ((.def_91 (<= 0.0 instance.y__AT0@0))) (let ((.def_92 (not .def_91))) (let ((.def_93 (<= (- (/ 1 2)) instance.y__AT0@0))) (let ((.def_94 (and .def_93 .def_92))) (let ((.def_95 (and .def_94 .def_90))) (let ((.def_96 (= time__AT0@0 0.0))) (let ((.def_97 (and .def_96 .def_95))) (let ((.def_98 (and .def_97 .def_85 .def_44 .def_1))) .def_98)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/exp-4.5-lt.smt2 b/test/regress/regress1/nl/exp-4.5-lt.smt2 new file mode 100644 index 000000000..b0d39ff44 --- /dev/null +++ b/test/regress/regress1/nl/exp-4.5-lt.smt2 @@ -0,0 +1,9 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(declare-fun x () Real) + +(assert (> (exp x) 2000.0)) +(assert (< x 4.5)) + +(check-sat) diff --git a/test/regress/regress1/nl/exp1-lb.smt2 b/test/regress/regress1/nl/exp1-lb.smt2 new file mode 100644 index 000000000..b0bc3079c --- /dev/null +++ b/test/regress/regress1/nl/exp1-lb.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) + +(assert (> (exp 1) 2.719)) +(assert (= x (exp 1))) + +(check-sat) diff --git a/test/regress/regress1/nl/exp_monotone.smt2 b/test/regress/regress1/nl/exp_monotone.smt2 new file mode 100644 index 000000000..a1360dc22 --- /dev/null +++ b/test/regress/regress1/nl/exp_monotone.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_UFNRA) +(set-info :status unsat) +(declare-fun x () Real) +(declare-fun y () Real) +(declare-fun z () Real) +(declare-fun w () Real) + +(assert (< x w)) + +(assert (> (exp x) (exp y))) +(assert (> (exp y) (exp z))) +(assert (> (exp z) (exp w))) + + +(check-sat) diff --git a/test/regress/regress1/nl/metitarski-1025.smt2 b/test/regress/regress1/nl/metitarski-1025.smt2 new file mode 100644 index 000000000..5a95364f3 --- /dev/null +++ b/test/regress/regress1/nl/metitarski-1025.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoCOSS () Real) +(declare-fun skoSINS () Real) +(declare-fun skoS () Real) +(declare-fun pi () Real) +(assert (and (= (* skoSINS skoSINS) (+ 1 (* skoCOSS (* skoCOSS (- 1))))) (and (not (<= (* pi (/ 1 2)) skoS)) (and (not (<= pi (/ 15707963 5000000))) (and (not (<= (/ 31415927 10000000) pi)) (and (<= 0 skoS) (and (<= 0 skoCOSS) (<= skoSINS skoS)))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/metitarski-3-4.smt2 b/test/regress/regress1/nl/metitarski-3-4.smt2 new file mode 100644 index 000000000..835d60732 --- /dev/null +++ b/test/regress/regress1/nl/metitarski-3-4.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoX () Real) +(declare-fun skoY () Real) +(declare-fun skoZ () Real) +(assert (let ((?v_0 (<= 0 skoY)) (?v_2 (<= (* skoZ (+ (- 1) (* skoY skoX))) (+ skoX skoY))) (?v_1 (* skoX (- 1)))) (let ((?v_3 (* skoX ?v_1))) (let ((?v_4 (* skoY (* skoX (+ (- 3) ?v_3))))) (and (<= (- 1) skoY) (and (not (= skoY 0)) (and (or (not ?v_2) ?v_0) (and (or ?v_0 (<= (* skoZ (+ 1 (* skoY ?v_1))) (+ (+ 1 ?v_1) (* skoY (+ (- 1) ?v_1))))) (and (or (not ?v_0) (or ?v_2 (<= (* skoZ (+ (+ 3 (* skoX skoX)) ?v_4)) (+ (* skoX ?v_3) (* skoY (+ (* skoX (* skoX (- 3))) ?v_4)))))) (and (not (<= skoZ 0)) (and (not (<= skoX (- 1))) (and (not (<= 1 skoY)) (not (<= skoY skoX)))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/metitarski_3_4_2e.smt2 b/test/regress/regress1/nl/metitarski_3_4_2e.smt2 new file mode 100644 index 000000000..3f12ec34b --- /dev/null +++ b/test/regress/regress1/nl/metitarski_3_4_2e.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status sat) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoX () Real) +(declare-fun skoS () Real) +(declare-fun skoC () Real) +(assert (let ((?v_0 (<= skoX 0)) (?v_2 (* skoC (/ 86400000 2025130727)))) (let ((?v_1 (<= ?v_2 skoS))) (and (<= (* skoX (+ (/ (- 69) 2000) (* skoX (/ (- 529) 16000000)))) 12) (and (not ?v_0) (and (or (not (<= (* skoX (+ (+ (+ (/ (- 23) 13) (* skoC (/ 621 8125))) (* skoS (/ (- 46578006721) 26000000000))) (* skoX (+ (+ (/ (- 529) 312000) (* skoC (/ (- 4761) 65000000))) (* skoS (/ 1071294154583 624000000000000)))))) (+ (+ (/ 8000 13) (* skoC (/ 1728 65))) (* skoS (/ (- 2025130727) 3250000))))) ?v_0) (and ?v_1 (and (or (not ?v_1) (not (<= skoS ?v_2))) (and (= (* skoS skoS) (+ 1 (* skoC (* skoC (- 1))))) (and (<= skoX 75) (<= 0 skoX))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/nl-help-unsat-quant.smt2 b/test/regress/regress1/nl/nl-help-unsat-quant.smt2 new file mode 100644 index 000000000..f2f7667c8 --- /dev/null +++ b/test/regress/regress1/nl/nl-help-unsat-quant.smt2 @@ -0,0 +1,419 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic UFNIA) +(set-info :status unsat) +(set-info :source |Benchmarks from the paper: "Extending Sledgehammer with SMT Solvers" by Jasmin Blanchette, Sascha Bohme, and Lawrence C. Paulson, CADE 2011. Translated to SMT2 by Andrew Reynolds and Morgan Deters.|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(declare-sort S1 0) +(declare-sort S2 0) +(declare-sort S3 0) +(declare-sort S4 0) +(declare-sort S5 0) +(declare-sort S6 0) +(declare-sort S7 0) +(declare-sort S8 0) +(declare-sort S9 0) +(declare-sort S10 0) +(declare-sort S11 0) +(declare-sort S12 0) +(declare-sort S13 0) +(declare-sort S14 0) +(declare-sort S15 0) +(declare-sort S16 0) +(declare-sort S17 0) +(declare-sort S18 0) +(declare-sort S19 0) +(declare-sort S20 0) +(declare-sort S21 0) +(declare-sort S22 0) +(declare-sort S23 0) +(declare-sort S24 0) +(declare-sort S25 0) +(declare-sort S26 0) +(declare-sort S27 0) +(declare-sort S28 0) +(declare-sort S29 0) +(declare-sort S30 0) +(declare-sort S31 0) +(declare-sort S32 0) +(declare-sort S33 0) +(declare-sort S34 0) +(declare-sort S35 0) +(declare-sort S36 0) +(declare-sort S37 0) +(declare-sort S38 0) +(declare-sort S39 0) +(declare-sort S40 0) +(declare-sort S41 0) +(declare-sort S42 0) +(declare-sort S43 0) +(declare-sort S44 0) +(declare-sort S45 0) +(declare-sort S46 0) +(declare-sort S47 0) +(declare-sort S48 0) +(declare-sort S49 0) +(declare-sort S50 0) +(declare-sort S51 0) +(declare-sort S52 0) +(declare-sort S53 0) +(declare-sort S54 0) +(declare-sort S55 0) +(declare-sort S56 0) +(declare-sort S57 0) +(declare-sort S58 0) +(declare-sort S59 0) +(declare-sort S60 0) +(declare-sort S61 0) +(declare-sort S62 0) +(declare-sort S63 0) +(declare-sort S64 0) +(declare-sort S65 0) +(declare-sort S66 0) +(declare-sort S67 0) +(declare-sort S68 0) +(declare-sort S69 0) +(declare-sort S70 0) +(declare-sort S71 0) +(declare-sort S72 0) +(declare-sort S73 0) +(declare-sort S74 0) +(declare-sort S75 0) +(declare-sort S76 0) +(declare-sort S77 0) +(declare-sort S78 0) +(declare-sort S79 0) +(declare-sort S80 0) +(declare-sort S81 0) +(declare-sort S82 0) +(declare-sort S83 0) +(declare-sort S84 0) +(declare-sort S85 0) +(declare-sort S86 0) +(declare-sort S87 0) +(declare-sort S88 0) +(declare-sort S89 0) +(declare-sort S90 0) +(declare-sort S91 0) +(declare-sort S92 0) +(declare-sort S93 0) +(declare-fun f1 () S1) +(declare-fun f2 () S1) +(declare-fun f3 (Int) S1) +(declare-fun f4 () Int) +(declare-fun f5 () Int) +(declare-fun f6 (S2 S3) Int) +(declare-fun f7 () S2) +(declare-fun f8 (S4 Int) S3) +(declare-fun f9 (S5 Int) S4) +(declare-fun f10 () S5) +(declare-fun f11 (S6 S3) S1) +(declare-fun f12 (S7 S8) S1) +(declare-fun f13 (S10 S9) S8) +(declare-fun f14 (S11 S9) S10) +(declare-fun f15 () S11) +(declare-fun f16 (S12 S13) S1) +(declare-fun f17 (S15 S14) S13) +(declare-fun f18 (S16 S14) S15) +(declare-fun f19 () S16) +(declare-fun f20 (S17 S14) S1) +(declare-fun f21 (S18 S3) S14) +(declare-fun f22 (S19 Int) S18) +(declare-fun f23 () S19) +(declare-fun f24 (S20 S21) S1) +(declare-fun f25 (S23 S22) S21) +(declare-fun f26 (S24 S22) S23) +(declare-fun f27 () S24) +(declare-fun f28 (S25 S22) S1) +(declare-fun f29 (S26 Int) S22) +(declare-fun f30 (S27 S3) S26) +(declare-fun f31 () S27) +(declare-fun f32 (S28 S9) S1) +(declare-fun f33 (S29 S3) S9) +(declare-fun f34 (S30 S3) S29) +(declare-fun f35 () S30) +(declare-fun f36 (S31 Int) S1) +(declare-fun f37 (S32 Int) S31) +(declare-fun f38 (S6) S32) +(declare-fun f39 (S3 S6) S1) +(declare-fun f40 (S33 S9) S28) +(declare-fun f41 (S7) S33) +(declare-fun f42 (S8 S7) S1) +(declare-fun f43 (S34 S14) S17) +(declare-fun f44 (S12) S34) +(declare-fun f45 (S13 S12) S1) +(declare-fun f46 (S35 S22) S25) +(declare-fun f47 (S20) S35) +(declare-fun f48 (S21 S20) S1) +(declare-fun f49 (S36 Int) S6) +(declare-fun f50 (S17) S36) +(declare-fun f51 (S14 S17) S1) +(declare-fun f52 (S37 S3) S31) +(declare-fun f53 (S25) S37) +(declare-fun f54 (S22 S25) S1) +(declare-fun f55 (S38 S3) S6) +(declare-fun f56 (S28) S38) +(declare-fun f57 (S9 S28) S1) +(declare-fun f58 (S39 S36) S28) +(declare-fun f59 (S31) S39) +(declare-fun f60 (S40 S38) S20) +(declare-fun f61 (S6) S40) +(declare-fun f62 (S41 S9) S7) +(declare-fun f63 (S42 S43) S1) +(declare-fun f64 (S8 S8) S42) +(declare-fun f65 (S44 S41) S43) +(declare-fun f66 (S28) S44) +(declare-fun f67 (S45 S14) S12) +(declare-fun f68 (S46 S47) S1) +(declare-fun f69 (S13 S13) S46) +(declare-fun f70 (S48 S45) S47) +(declare-fun f71 (S17) S48) +(declare-fun f72 (S49 S22) S20) +(declare-fun f73 (S50 S51) S1) +(declare-fun f74 (S21 S21) S50) +(declare-fun f75 (S52 S49) S51) +(declare-fun f76 (S25) S52) +(declare-fun f77 (S53 S3) S28) +(declare-fun f78 (S54 S53) S7) +(declare-fun f79 (S6) S54) +(declare-fun f80 (S55 Int) S28) +(declare-fun f81 (S56 S55) S12) +(declare-fun f82 (S31) S56) +(declare-fun f83 (S6) S1) +(declare-fun f84 (S7) S1) +(declare-fun f85 (S12) S1) +(declare-fun f86 (S20) S1) +(declare-fun f87 (S28) S1) +(declare-fun f88 (S6) S1) +(declare-fun f89 (S7) S1) +(declare-fun f90 (S12) S1) +(declare-fun f91 (S20) S1) +(declare-fun f92 (S28) S1) +(declare-fun f93 (S6) S32) +(declare-fun f94 (S7) S33) +(declare-fun f95 (S12) S34) +(declare-fun f96 (S17) S36) +(declare-fun f97 (S20) S35) +(declare-fun f98 (S25) S37) +(declare-fun f99 (S28) S38) +(declare-fun f100 (S57 S58) S1) +(declare-fun f101 (S59 S59) S57) +(declare-fun f102 (S9 Int) S59) +(declare-fun f103 (S7 S6) S58) +(declare-fun f104 (S60 S61) S1) +(declare-fun f105 (S62 S62) S60) +(declare-fun f106 (S14 Int) S62) +(declare-fun f107 (S12 S6) S61) +(declare-fun f108 (S63 S64) S1) +(declare-fun f109 (S65 S65) S63) +(declare-fun f110 (S22 Int) S65) +(declare-fun f111 (S20 S6) S64) +(declare-fun f112 (S66 S6) S20) +(declare-fun f113 (S28) S66) +(declare-fun f114 (S67 S68) S1) +(declare-fun f115 (S69 S69) S67) +(declare-fun f116 (Int S9) S69) +(declare-fun f117 (S6 S7) S68) +(declare-fun f118 (S70 S71) S1) +(declare-fun f119 (S72 S72) S70) +(declare-fun f120 (Int S14) S72) +(declare-fun f121 (S6 S12) S71) +(declare-fun f122 (S73 S74) S1) +(declare-fun f123 (S75 S75) S73) +(declare-fun f124 (Int S22) S75) +(declare-fun f125 (S6 S20) S74) +(declare-fun f126 (S76 S28) S12) +(declare-fun f127 (S6) S76) +(declare-fun f128 (S77 S6) S28) +(declare-fun f129 (S6) S77) +(declare-fun f130 (S78 S7) S43) +(declare-fun f131 (S7) S78) +(declare-fun f132 (S79 S12) S47) +(declare-fun f133 (S12) S79) +(declare-fun f134 (S80 S20) S51) +(declare-fun f135 (S20) S80) +(declare-fun f136 (S81 S28) S7) +(declare-fun f137 (S28) S81) +(declare-fun f138 (S82) S6) +(declare-fun f139 (S83 S84) Int) +(declare-fun f140 () S83) +(declare-fun f141 (S82 Int) S84) +(declare-fun f142 (S85) S7) +(declare-fun f143 (S85 S9) S84) +(declare-fun f144 (S86) S12) +(declare-fun f145 (S86 S14) S84) +(declare-fun f146 (S87) S20) +(declare-fun f147 (S87 S22) S84) +(declare-fun f148 (S88) S28) +(declare-fun f149 (S88 S3) S84) +(declare-fun f150 (S89 S6) S6) +(declare-fun f151 (S82) S89) +(declare-fun f152 (S90 S7) S7) +(declare-fun f153 (S85) S90) +(declare-fun f154 (S91 S12) S12) +(declare-fun f155 (S86) S91) +(declare-fun f156 (S92 S20) S20) +(declare-fun f157 (S87) S92) +(declare-fun f158 (S93 S28) S28) +(declare-fun f159 (S88) S93) +(declare-fun f160 (S31 S6) S1) +(declare-fun f161 (Int S31) S1) +(declare-fun f162 (S17 S12) S1) +(declare-fun f163 (S25 S20) S1) +(declare-fun f164 (S7 S43) S1) +(declare-fun f165 (S12 S47) S1) +(declare-fun f166 (S20 S51) S1) +(declare-fun f167 (S28 S7) S1) +(declare-fun f168 (S6 S28) S1) +(declare-fun f169 () S82) +(assert (not (= f1 f2))) +(assert (not (= (f3 (* f4 f5)) f1))) +(assert (= (f3 f4) f1)) +(assert (= (f3 f5) f1)) +(assert (forall ((?v0 Int)) (= (= (f3 ?v0) f1) (exists ((?v1 Int) (?v2 Int)) (= (f6 f7 (f8 (f9 f10 ?v1) ?v2)) ?v0))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (* (f6 f7 (f8 (f9 f10 ?v0) ?v1)) (f6 f7 (f8 (f9 f10 ?v2) ?v3))) (f6 f7 (f8 (f9 f10 (+ (* ?v0 ?v2) (* ?v1 ?v3))) (- (* ?v0 ?v3) (* ?v1 ?v2))))))) +(assert (forall ((?v0 S6)) (= (forall ((?v1 S3)) (= (f11 ?v0 ?v1) f1)) (forall ((?v1 Int) (?v2 Int)) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S7)) (= (forall ((?v1 S8)) (= (f12 ?v0 ?v1) f1)) (forall ((?v1 S9) (?v2 S9)) (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S12)) (= (forall ((?v1 S13)) (= (f16 ?v0 ?v1) f1)) (forall ((?v1 S14) (?v2 S14)) (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S17)) (= (forall ((?v1 S14)) (= (f20 ?v0 ?v1) f1)) (forall ((?v1 Int) (?v2 S3)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S20)) (= (forall ((?v1 S21)) (= (f24 ?v0 ?v1) f1)) (forall ((?v1 S22) (?v2 S22)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S25)) (= (forall ((?v1 S22)) (= (f28 ?v0 ?v1) f1)) (forall ((?v1 S3) (?v2 Int)) (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S28)) (= (forall ((?v1 S9)) (= (f32 ?v0 ?v1) f1)) (forall ((?v1 S3) (?v2 S3)) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S9) (?v3 S9)) (= (= (f13 (f14 f15 ?v0) ?v1) (f13 (f14 f15 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S14) (?v3 S14)) (= (= (f17 (f18 f19 ?v0) ?v1) (f17 (f18 f19 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3)) (= (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S22) (?v3 S22)) (= (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int)) (= (= (f29 (f30 f31 ?v0) ?v1) (f29 (f30 f31 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (= (= (f33 (f34 f35 ?v0) ?v1) (f33 (f34 f35 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (=> (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S9) (?v3 S9)) (=> (= (f13 (f14 f15 ?v0) ?v1) (f13 (f14 f15 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S14) (?v3 S14)) (=> (= (f17 (f18 f19 ?v0) ?v1) (f17 (f18 f19 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3)) (=> (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S22) (?v3 S22)) (=> (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int)) (=> (= (f29 (f30 f31 ?v0) ?v1) (f29 (f30 f31 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (=> (= (f33 (f34 f35 ?v0) ?v1) (f33 (f34 f35 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (= (= (f36 (f37 (f38 ?v0) ?v1) ?v2) f1) (= (f39 (f8 (f9 f10 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (= (= (f32 (f40 (f41 ?v0) ?v1) ?v2) f1) (= (f42 (f13 (f14 f15 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (= (= (f20 (f43 (f44 ?v0) ?v1) ?v2) f1) (= (f45 (f17 (f18 f19 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (= (= (f28 (f46 (f47 ?v0) ?v1) ?v2) f1) (= (f48 (f25 (f26 f27 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (= (= (f11 (f49 (f50 ?v0) ?v1) ?v2) f1) (= (f51 (f21 (f22 f23 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (= (= (f36 (f52 (f53 ?v0) ?v1) ?v2) f1) (= (f54 (f29 (f30 f31 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (= (= (f11 (f55 (f56 ?v0) ?v1) ?v2) f1) (= (f57 (f33 (f34 f35 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S31) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S36)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f36 ?v0 ?v1) f1) (=> (= (f39 (f8 (f9 f10 ?v2) ?v3) (f49 ?v4 ?v1)) f1) (= (f57 (f33 (f34 f35 (f8 ?v_0 ?v2)) (f8 ?v_0 ?v3)) (f58 (f59 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6) (?v1 S3) (?v2 Int) (?v3 Int) (?v4 S38)) (let ((?v_0 (f30 f31 ?v1))) (=> (= (f11 ?v0 ?v1) f1) (=> (= (f39 (f8 (f9 f10 ?v2) ?v3) (f55 ?v4 ?v1)) f1) (= (f48 (f25 (f26 f27 (f29 ?v_0 ?v2)) (f29 ?v_0 ?v3)) (f60 (f61 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S28) (?v1 S9) (?v2 S9) (?v3 S9) (?v4 S41)) (let ((?v_0 (f14 f15 ?v1))) (=> (= (f32 ?v0 ?v1) f1) (=> (= (f42 (f13 (f14 f15 ?v2) ?v3) (f62 ?v4 ?v1)) f1) (= (f63 (f64 (f13 ?v_0 ?v2) (f13 ?v_0 ?v3)) (f65 (f66 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S17) (?v1 S14) (?v2 S14) (?v3 S14) (?v4 S45)) (let ((?v_0 (f18 f19 ?v1))) (=> (= (f20 ?v0 ?v1) f1) (=> (= (f45 (f17 (f18 f19 ?v2) ?v3) (f67 ?v4 ?v1)) f1) (= (f68 (f69 (f17 ?v_0 ?v2) (f17 ?v_0 ?v3)) (f70 (f71 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S25) (?v1 S22) (?v2 S22) (?v3 S22) (?v4 S49)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f28 ?v0 ?v1) f1) (=> (= (f48 (f25 (f26 f27 ?v2) ?v3) (f72 ?v4 ?v1)) f1) (= (f73 (f74 (f25 ?v_0 ?v2) (f25 ?v_0 ?v3)) (f75 (f76 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S53)) (let ((?v_0 (f34 f35 ?v1))) (=> (= (f11 ?v0 ?v1) f1) (=> (= (f57 (f33 (f34 f35 ?v2) ?v3) (f77 ?v4 ?v1)) f1) (= (f42 (f13 (f14 f15 (f33 ?v_0 ?v2)) (f33 ?v_0 ?v3)) (f78 (f79 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S31) (?v1 Int) (?v2 S3) (?v3 S3) (?v4 S55)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f36 ?v0 ?v1) f1) (=> (= (f57 (f33 (f34 f35 ?v2) ?v3) (f80 ?v4 ?v1)) f1) (= (f45 (f17 (f18 f19 (f21 ?v_0 ?v2)) (f21 ?v_0 ?v3)) (f81 (f82 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6)) (= (= (f83 ?v0) f1) (forall ((?v1 Int)) (= (f39 (f8 (f9 f10 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S7)) (= (= (f84 ?v0) f1) (forall ((?v1 S9)) (= (f42 (f13 (f14 f15 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S12)) (= (= (f85 ?v0) f1) (forall ((?v1 S14)) (= (f45 (f17 (f18 f19 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S20)) (= (= (f86 ?v0) f1) (forall ((?v1 S22)) (= (f48 (f25 (f26 f27 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S28)) (= (= (f87 ?v0) f1) (forall ((?v1 S3)) (= (f57 (f33 (f34 f35 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S6)) (= (= (f88 ?v0) f1) (forall ((?v1 Int)) (not (= (f39 (f8 (f9 f10 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S7)) (= (= (f89 ?v0) f1) (forall ((?v1 S9)) (not (= (f42 (f13 (f14 f15 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S12)) (= (= (f90 ?v0) f1) (forall ((?v1 S14)) (not (= (f45 (f17 (f18 f19 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S20)) (= (= (f91 ?v0) f1) (forall ((?v1 S22)) (not (= (f48 (f25 (f26 f27 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S28)) (= (= (f92 ?v0) f1) (forall ((?v1 S3)) (not (= (f57 (f33 (f34 f35 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S6)) (= (exists ((?v1 S3)) (= (f11 ?v0 ?v1) f1)) (exists ((?v1 Int) (?v2 Int)) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S7)) (= (exists ((?v1 S8)) (= (f12 ?v0 ?v1) f1)) (exists ((?v1 S9) (?v2 S9)) (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S12)) (= (exists ((?v1 S13)) (= (f16 ?v0 ?v1) f1)) (exists ((?v1 S14) (?v2 S14)) (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S17)) (= (exists ((?v1 S14)) (= (f20 ?v0 ?v1) f1)) (exists ((?v1 Int) (?v2 S3)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S20)) (= (exists ((?v1 S21)) (= (f24 ?v0 ?v1) f1)) (exists ((?v1 S22) (?v2 S22)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S25)) (= (exists ((?v1 S22)) (= (f28 ?v0 ?v1) f1)) (exists ((?v1 S3) (?v2 Int)) (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S28)) (= (exists ((?v1 S9)) (= (f32 ?v0 ?v1) f1)) (exists ((?v1 S3) (?v2 S3)) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S3) (?v3 Int) (?v4 Int)) (=> (= ?v0 (f13 (f14 f15 ?v1) (f33 (f34 f35 ?v2) (f8 (f9 f10 ?v3) ?v4)))) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 Int) (?v3 Int) (?v4 Int)) (=> (= ?v0 (f17 (f18 f19 ?v1) (f21 (f22 f23 ?v2) (f8 (f9 f10 ?v3) ?v4)))) false)) false))) +(assert (forall ((?v0 S7) (?v1 S8)) (=> (forall ((?v2 S9) (?v3 S3) (?v4 Int) (?v5 Int)) (= (f12 ?v0 (f13 (f14 f15 ?v2) (f33 (f34 f35 ?v3) (f8 (f9 f10 ?v4) ?v5)))) f1)) (= (f12 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S12) (?v1 S13)) (=> (forall ((?v2 S14) (?v3 Int) (?v4 Int) (?v5 Int)) (= (f16 ?v0 (f17 (f18 f19 ?v2) (f21 (f22 f23 ?v3) (f8 (f9 f10 ?v4) ?v5)))) f1)) (= (f16 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S9)) (=> (forall ((?v1 S3) (?v2 Int) (?v3 Int)) (=> (= ?v0 (f33 (f34 f35 ?v1) (f8 (f9 f10 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 Int) (?v3 S3)) (=> (= ?v0 (f17 (f18 f19 ?v1) (f21 (f22 f23 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S14)) (=> (forall ((?v1 Int) (?v2 Int) (?v3 Int)) (=> (= ?v0 (f21 (f22 f23 ?v1) (f8 (f9 f10 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S22) (?v2 S3) (?v3 Int)) (=> (= ?v0 (f25 (f26 f27 ?v1) (f29 (f30 f31 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S3) (?v3 S3)) (=> (= ?v0 (f13 (f14 f15 ?v1) (f33 (f34 f35 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S28) (?v1 S9)) (=> (forall ((?v2 S3) (?v3 Int) (?v4 Int)) (= (f32 ?v0 (f33 (f34 f35 ?v2) (f8 (f9 f10 ?v3) ?v4))) f1)) (= (f32 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S12) (?v1 S13)) (=> (forall ((?v2 S14) (?v3 Int) (?v4 S3)) (= (f16 ?v0 (f17 (f18 f19 ?v2) (f21 (f22 f23 ?v3) ?v4))) f1)) (= (f16 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S17) (?v1 S14)) (=> (forall ((?v2 Int) (?v3 Int) (?v4 Int)) (= (f20 ?v0 (f21 (f22 f23 ?v2) (f8 (f9 f10 ?v3) ?v4))) f1)) (= (f20 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S20) (?v1 S21)) (=> (forall ((?v2 S22) (?v3 S3) (?v4 Int)) (= (f24 ?v0 (f25 (f26 f27 ?v2) (f29 (f30 f31 ?v3) ?v4))) f1)) (= (f24 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S7) (?v1 S8)) (=> (forall ((?v2 S9) (?v3 S3) (?v4 S3)) (= (f12 ?v0 (f13 (f14 f15 ?v2) (f33 (f34 f35 ?v3) ?v4))) f1)) (= (f12 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S9)) (=> (= ?v0 (f13 (f14 f15 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 S14)) (=> (= ?v0 (f17 (f18 f19 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S14)) (=> (forall ((?v1 Int) (?v2 S3)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S22) (?v2 S22)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S22)) (=> (forall ((?v1 S3) (?v2 Int)) (=> (= ?v0 (f29 (f30 f31 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S9)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f33 (f34 f35 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S9)) (=> (= ?v0 (f13 (f14 f15 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 S14)) (=> (= ?v0 (f17 (f18 f19 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S14)) (=> (forall ((?v1 Int) (?v2 S3)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S22) (?v2 S22)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S22)) (=> (forall ((?v1 S3) (?v2 Int)) (=> (= ?v0 (f29 (f30 f31 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S9)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f33 (f34 f35 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (=> (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (=> (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1) (= (f32 (f40 (f94 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (=> (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1) (= (f20 (f43 (f95 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) (= (f11 (f49 (f96 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) (= (f28 (f46 (f97 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (=> (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1) (= (f36 (f52 (f98 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (=> (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1) (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S9) (?v1 Int) (?v2 S9) (?v3 Int) (?v4 S7) (?v5 S6)) (= (= (f100 (f101 (f102 ?v0 ?v1) (f102 ?v2 ?v3)) (f103 ?v4 ?v5)) f1) (or (= (f42 (f13 (f14 f15 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S14) (?v1 Int) (?v2 S14) (?v3 Int) (?v4 S12) (?v5 S6)) (= (= (f104 (f105 (f106 ?v0 ?v1) (f106 ?v2 ?v3)) (f107 ?v4 ?v5)) f1) (or (= (f45 (f17 (f18 f19 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S22) (?v1 Int) (?v2 S22) (?v3 Int) (?v4 S20) (?v5 S6)) (= (= (f108 (f109 (f110 ?v0 ?v1) (f110 ?v2 ?v3)) (f111 ?v4 ?v5)) f1) (or (= (f48 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int) (?v4 S28) (?v5 S6)) (= (= (f48 (f25 (f26 f27 (f29 (f30 f31 ?v0) ?v1)) (f29 (f30 f31 ?v2) ?v3)) (f112 (f113 ?v4) ?v5)) f1) (or (= (f57 (f33 (f34 f35 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S9) (?v2 Int) (?v3 S9) (?v4 S6) (?v5 S7)) (= (= (f114 (f115 (f116 ?v0 ?v1) (f116 ?v2 ?v3)) (f117 ?v4 ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f42 (f13 (f14 f15 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S14) (?v2 Int) (?v3 S14) (?v4 S6) (?v5 S12)) (= (= (f118 (f119 (f120 ?v0 ?v1) (f120 ?v2 ?v3)) (f121 ?v4 ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f45 (f17 (f18 f19 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S22) (?v2 Int) (?v3 S22) (?v4 S6) (?v5 S20)) (= (= (f122 (f123 (f124 ?v0 ?v1) (f124 ?v2 ?v3)) (f125 ?v4 ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f48 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3) (?v4 S6) (?v5 S28)) (= (= (f45 (f17 (f18 f19 (f21 (f22 f23 ?v0) ?v1)) (f21 (f22 f23 ?v2) ?v3)) (f126 (f127 ?v4) ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f57 (f33 (f34 f35 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S6) (?v5 S6)) (let ((?v_0 (f9 f10 ?v0))) (= (= (f57 (f33 (f34 f35 (f8 ?v_0 ?v1)) (f8 (f9 f10 ?v2) ?v3)) (f128 (f129 ?v4) ?v5)) f1) (or (= (f39 (f8 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S9) (?v3 S9) (?v4 S7) (?v5 S7)) (let ((?v_0 (f14 f15 ?v0))) (= (= (f63 (f64 (f13 ?v_0 ?v1) (f13 (f14 f15 ?v2) ?v3)) (f130 (f131 ?v4) ?v5)) f1) (or (= (f42 (f13 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f42 (f13 (f14 f15 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S14) (?v3 S14) (?v4 S12) (?v5 S12)) (let ((?v_0 (f18 f19 ?v0))) (= (= (f68 (f69 (f17 ?v_0 ?v1) (f17 (f18 f19 ?v2) ?v3)) (f132 (f133 ?v4) ?v5)) f1) (or (= (f45 (f17 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f45 (f17 (f18 f19 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S22) (?v3 S22) (?v4 S20) (?v5 S20)) (let ((?v_0 (f26 f27 ?v0))) (= (= (f73 (f74 (f25 ?v_0 ?v1) (f25 (f26 f27 ?v2) ?v3)) (f134 (f135 ?v4) ?v5)) f1) (or (= (f48 (f25 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f48 (f25 (f26 f27 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S28) (?v5 S28)) (let ((?v_0 (f34 f35 ?v0))) (= (= (f42 (f13 (f14 f15 (f33 ?v_0 ?v1)) (f33 (f34 f35 ?v2) ?v3)) (f136 (f137 ?v4) ?v5)) f1) (or (= (f57 (f33 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f57 (f33 (f34 f35 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (= (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (= (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (=> (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (=> (= (f32 (f40 (f94 ?v0) ?v1) ?v2) f1) (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (=> (= (f20 (f43 (f95 ?v0) ?v1) ?v2) f1) (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (=> (= (f11 (f49 (f96 ?v0) ?v1) ?v2) f1) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (=> (= (f28 (f46 (f97 ?v0) ?v1) ?v2) f1) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (=> (= (f36 (f52 (f98 ?v0) ?v1) ?v2) f1) (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (=> (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (=> (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1) (=> (=> (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (=> (= (f32 (f40 (f94 ?v0) ?v1) ?v2) f1) (=> (=> (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (=> (= (f20 (f43 (f95 ?v0) ?v1) ?v2) f1) (=> (=> (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (=> (= (f11 (f49 (f96 ?v0) ?v1) ?v2) f1) (=> (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (=> (= (f28 (f46 (f97 ?v0) ?v1) ?v2) f1) (=> (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (=> (= (f36 (f52 (f98 ?v0) ?v1) ?v2) f1) (=> (=> (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (=> (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1) (=> (=> (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S82)) (= (= (f39 (f8 (f9 f10 ?v0) ?v1) (f138 ?v2)) f1) (< (f139 f140 (f141 ?v2 ?v0)) (f139 f140 (f141 ?v2 ?v1)))))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S85)) (= (= (f42 (f13 (f14 f15 ?v0) ?v1) (f142 ?v2)) f1) (< (f139 f140 (f143 ?v2 ?v0)) (f139 f140 (f143 ?v2 ?v1)))))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S86)) (= (= (f45 (f17 (f18 f19 ?v0) ?v1) (f144 ?v2)) f1) (< (f139 f140 (f145 ?v2 ?v0)) (f139 f140 (f145 ?v2 ?v1)))))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S87)) (= (= (f48 (f25 (f26 f27 ?v0) ?v1) (f146 ?v2)) f1) (< (f139 f140 (f147 ?v2 ?v0)) (f139 f140 (f147 ?v2 ?v1)))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S88)) (= (= (f57 (f33 (f34 f35 ?v0) ?v1) (f148 ?v2)) f1) (< (f139 f140 (f149 ?v2 ?v0)) (f139 f140 (f149 ?v2 ?v1)))))) +(assert (forall ((?v0 S82) (?v1 Int) (?v2 Int) (?v3 S6)) (=> (< (f139 f140 (f141 ?v0 ?v1)) (f139 f140 (f141 ?v0 ?v2))) (= (f39 (f8 (f9 f10 ?v1) ?v2) (f150 (f151 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S85) (?v1 S9) (?v2 S9) (?v3 S7)) (=> (< (f139 f140 (f143 ?v0 ?v1)) (f139 f140 (f143 ?v0 ?v2))) (= (f42 (f13 (f14 f15 ?v1) ?v2) (f152 (f153 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S86) (?v1 S14) (?v2 S14) (?v3 S12)) (=> (< (f139 f140 (f145 ?v0 ?v1)) (f139 f140 (f145 ?v0 ?v2))) (= (f45 (f17 (f18 f19 ?v1) ?v2) (f154 (f155 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S87) (?v1 S22) (?v2 S22) (?v3 S20)) (=> (< (f139 f140 (f147 ?v0 ?v1)) (f139 f140 (f147 ?v0 ?v2))) (= (f48 (f25 (f26 f27 ?v1) ?v2) (f156 (f157 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S88) (?v1 S3) (?v2 S3) (?v3 S28)) (=> (< (f139 f140 (f149 ?v0 ?v1)) (f139 f140 (f149 ?v0 ?v2))) (= (f57 (f33 (f34 f35 ?v1) ?v2) (f158 (f159 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S82) (?v1 Int) (?v2 Int) (?v3 S6)) (let ((?v_0 (f8 (f9 f10 ?v1) ?v2))) (=> (<= (f139 f140 (f141 ?v0 ?v1)) (f139 f140 (f141 ?v0 ?v2))) (=> (= (f39 ?v_0 ?v3) f1) (= (f39 ?v_0 (f150 (f151 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S85) (?v1 S9) (?v2 S9) (?v3 S7)) (let ((?v_0 (f13 (f14 f15 ?v1) ?v2))) (=> (<= (f139 f140 (f143 ?v0 ?v1)) (f139 f140 (f143 ?v0 ?v2))) (=> (= (f42 ?v_0 ?v3) f1) (= (f42 ?v_0 (f152 (f153 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S86) (?v1 S14) (?v2 S14) (?v3 S12)) (let ((?v_0 (f17 (f18 f19 ?v1) ?v2))) (=> (<= (f139 f140 (f145 ?v0 ?v1)) (f139 f140 (f145 ?v0 ?v2))) (=> (= (f45 ?v_0 ?v3) f1) (= (f45 ?v_0 (f154 (f155 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S87) (?v1 S22) (?v2 S22) (?v3 S20)) (let ((?v_0 (f25 (f26 f27 ?v1) ?v2))) (=> (<= (f139 f140 (f147 ?v0 ?v1)) (f139 f140 (f147 ?v0 ?v2))) (=> (= (f48 ?v_0 ?v3) f1) (= (f48 ?v_0 (f156 (f157 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S88) (?v1 S3) (?v2 S3) (?v3 S28)) (let ((?v_0 (f33 (f34 f35 ?v1) ?v2))) (=> (<= (f139 f140 (f149 ?v0 ?v1)) (f139 f140 (f149 ?v0 ?v2))) (=> (= (f57 ?v_0 ?v3) f1) (= (f57 ?v_0 (f158 (f159 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S31) (?v1 S6)) (= (= (f160 ?v0 ?v1) f1) (forall ((?v2 Int)) (=> (= (f161 ?v2 ?v0) f1) (forall ((?v3 Int)) (=> (= (f161 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f39 (f8 (f9 f10 ?v2) ?v3) ?v1) f1) (= (f39 (f8 (f9 f10 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S17) (?v1 S12)) (= (= (f162 ?v0 ?v1) f1) (forall ((?v2 S14)) (=> (= (f51 ?v2 ?v0) f1) (forall ((?v3 S14)) (=> (= (f51 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f45 (f17 (f18 f19 ?v2) ?v3) ?v1) f1) (= (f45 (f17 (f18 f19 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S25) (?v1 S20)) (= (= (f163 ?v0 ?v1) f1) (forall ((?v2 S22)) (=> (= (f54 ?v2 ?v0) f1) (forall ((?v3 S22)) (=> (= (f54 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f48 (f25 (f26 f27 ?v2) ?v3) ?v1) f1) (= (f48 (f25 (f26 f27 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S7) (?v1 S43)) (= (= (f164 ?v0 ?v1) f1) (forall ((?v2 S8)) (=> (= (f42 ?v2 ?v0) f1) (forall ((?v3 S8)) (=> (= (f42 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f63 (f64 ?v2 ?v3) ?v1) f1) (= (f63 (f64 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S12) (?v1 S47)) (= (= (f165 ?v0 ?v1) f1) (forall ((?v2 S13)) (=> (= (f45 ?v2 ?v0) f1) (forall ((?v3 S13)) (=> (= (f45 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f68 (f69 ?v2 ?v3) ?v1) f1) (= (f68 (f69 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S20) (?v1 S51)) (= (= (f166 ?v0 ?v1) f1) (forall ((?v2 S21)) (=> (= (f48 ?v2 ?v0) f1) (forall ((?v3 S21)) (=> (= (f48 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f73 (f74 ?v2 ?v3) ?v1) f1) (= (f73 (f74 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S28) (?v1 S7)) (= (= (f167 ?v0 ?v1) f1) (forall ((?v2 S9)) (=> (= (f57 ?v2 ?v0) f1) (forall ((?v3 S9)) (=> (= (f57 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f42 (f13 (f14 f15 ?v2) ?v3) ?v1) f1) (= (f42 (f13 (f14 f15 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S6) (?v1 S28)) (= (= (f168 ?v0 ?v1) f1) (forall ((?v2 S3)) (=> (= (f39 ?v2 ?v0) f1) (forall ((?v3 S3)) (=> (= (f39 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f57 (f33 (f34 f35 ?v2) ?v3) ?v1) f1) (= (f57 (f33 (f34 f35 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S84)) (= (f141 f169 (f139 f140 ?v0)) ?v0))) +(assert (forall ((?v0 Int)) (=> (<= 0 ?v0) (= (f139 f140 (f141 f169 ?v0)) ?v0)))) +(assert (forall ((?v0 Int)) (=> (< ?v0 0) (= (f139 f140 (f141 f169 ?v0)) 0)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/nl-unk-quant.smt2 b/test/regress/regress1/nl/nl-unk-quant.smt2 new file mode 100644 index 000000000..bb5cd43df --- /dev/null +++ b/test/regress/regress1/nl/nl-unk-quant.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic UFNIA) +(set-info :source |Benchmarks from the paper: "Extending Sledgehammer with SMT Solvers" by Jasmin Blanchette, Sascha Bohme, and Lawrence C. Paulson, CADE 2011. Translated to SMT2 by Andrew Reynolds and Morgan Deters.|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-sort S1 0) +(declare-sort S2 0) +(declare-sort S3 0) +(declare-sort S4 0) +(declare-fun f1 () S1) +(declare-fun f2 () S1) +(declare-fun f3 () S2) +(declare-fun f4 (S3 Int) S2) +(declare-fun f5 () S3) +(declare-fun f6 (S4 S2) Int) +(declare-fun f7 () S4) +(declare-fun f8 () Int) +(declare-fun f9 (Int) S1) +(declare-fun f10 () Int) +(declare-fun f11 () S2) +(assert (not (= f1 f2))) +(assert (let ((?v_0 (f6 f7 f3)) (?v_1 (f6 f7 f11))) (not (=> (and (= f3 (f4 f5 (- (f6 f7 (f4 f5 f8)) 1))) (= (f9 (* (+ (* 4 f10) 1) (+ 1 ?v_0))) f1)) (=> (< f8 (+ 1 ?v_1)) (=> (< 0 f8) (< ?v_0 ?v_1))))))) +(assert (forall ((?v0 S2)) (= (f4 f5 (f6 f7 ?v0)) ?v0))) +(assert (forall ((?v0 Int)) (=> (<= 0 ?v0) (= (f6 f7 (f4 f5 ?v0)) ?v0)))) +(assert (forall ((?v0 Int)) (=> (< ?v0 0) (= (f6 f7 (f4 f5 ?v0)) 0)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/ones.smt2 b/test/regress/regress1/nl/ones.smt2 new file mode 100644 index 000000000..be06912d0 --- /dev/null +++ b/test/regress/regress1/nl/ones.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(declare-fun d () Real) + +(assert (>= a 1)) +(assert (>= b 1)) +(assert (>= c 1)) +(assert (>= d 1)) +(assert (or (= a 1) (= b 1) (= c 1) (= d 1))) + +(assert (< (* a b c d) 1)) + +(check-sat) diff --git a/test/regress/regress1/nl/poly-1025.smt2 b/test/regress/regress1/nl/poly-1025.smt2 new file mode 100644 index 000000000..482696532 --- /dev/null +++ b/test/regress/regress1/nl/poly-1025.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoX () Real) +(declare-fun skoY () Real) +(declare-fun skoZ () Real) +(assert (let ((?v_2 (not (<= skoZ 1)))) (let ((?v_3 (or (not (<= skoY 1)) ?v_2)) (?v_4 (not (<= skoX 1))) (?v_0 (* skoX (/ 1 4))) (?v_1 (* skoX (/ (- 5) 4))) (?v_5 (* skoX (/ 1 2))) (?v_6 (+ (/ (- 1) 4) (* skoX (/ (- 1) 4))))) (and (not (<= skoX 0)) (and (or (not (<= (* skoZ (* skoY (* skoY (+ (* skoX (* skoX (+ (/ (- 15) 4) ?v_0))) (* skoY (* skoX (* skoX (+ (/ 1 4) ?v_0)))))))) (* skoY (+ (* skoX (+ (/ 11 4) ?v_1)) (* skoY (* skoX (+ (/ (- 5) 4) ?v_1))))))) ?v_2) (and ?v_3 (and (or ?v_4 ?v_3) (and (<= skoZ 2) (and (<= skoY 2) (and (<= skoX 2) (and (<= 1 skoZ) (and (<= 1 skoY) (and (<= 1 skoX) (and (or ?v_4 ?v_2) (or (not (<= (* skoZ (* skoY (+ (* skoX (+ (/ (- 7) 2) ?v_5)) (* skoY (* skoX (+ (/ 1 2) ?v_5)))))) (+ ?v_6 (* skoY ?v_6)))) ?v_2))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/quant-nl.smt2 b/test/regress/regress1/nl/quant-nl.smt2 new file mode 100644 index 000000000..7d251ab7d --- /dev/null +++ b/test/regress/regress1/nl/quant-nl.smt2 @@ -0,0 +1,857 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic UFNIA) +(set-info :status unsat) +(set-info :source |Benchmarks from the paper: "Extending Sledgehammer with SMT Solvers" by Jasmin Blanchette, Sascha Bohme, and Lawrence C. Paulson, CADE 2011. Translated to SMT2 by Andrew Reynolds and Morgan Deters.|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(declare-sort S1 0) +(declare-sort S2 0) +(declare-sort S3 0) +(declare-sort S4 0) +(declare-sort S5 0) +(declare-sort S6 0) +(declare-sort S7 0) +(declare-sort S8 0) +(declare-sort S9 0) +(declare-sort S10 0) +(declare-sort S11 0) +(declare-sort S12 0) +(declare-sort S13 0) +(declare-sort S14 0) +(declare-sort S15 0) +(declare-sort S16 0) +(declare-sort S17 0) +(declare-sort S18 0) +(declare-sort S19 0) +(declare-sort S20 0) +(declare-sort S21 0) +(declare-sort S22 0) +(declare-sort S23 0) +(declare-sort S24 0) +(declare-sort S25 0) +(declare-sort S26 0) +(declare-sort S27 0) +(declare-sort S28 0) +(declare-sort S29 0) +(declare-sort S30 0) +(declare-sort S31 0) +(declare-sort S32 0) +(declare-sort S33 0) +(declare-sort S34 0) +(declare-sort S35 0) +(declare-sort S36 0) +(declare-sort S37 0) +(declare-sort S38 0) +(declare-sort S39 0) +(declare-sort S40 0) +(declare-sort S41 0) +(declare-sort S42 0) +(declare-sort S43 0) +(declare-sort S44 0) +(declare-sort S45 0) +(declare-sort S46 0) +(declare-sort S47 0) +(declare-sort S48 0) +(declare-sort S49 0) +(declare-sort S50 0) +(declare-sort S51 0) +(declare-sort S52 0) +(declare-sort S53 0) +(declare-sort S54 0) +(declare-sort S55 0) +(declare-sort S56 0) +(declare-sort S57 0) +(declare-sort S58 0) +(declare-sort S59 0) +(declare-sort S60 0) +(declare-sort S61 0) +(declare-sort S62 0) +(declare-sort S63 0) +(declare-sort S64 0) +(declare-sort S65 0) +(declare-sort S66 0) +(declare-sort S67 0) +(declare-sort S68 0) +(declare-sort S69 0) +(declare-sort S70 0) +(declare-sort S71 0) +(declare-sort S72 0) +(declare-sort S73 0) +(declare-sort S74 0) +(declare-sort S75 0) +(declare-sort S76 0) +(declare-sort S77 0) +(declare-sort S78 0) +(declare-sort S79 0) +(declare-sort S80 0) +(declare-sort S81 0) +(declare-sort S82 0) +(declare-sort S83 0) +(declare-sort S84 0) +(declare-sort S85 0) +(declare-sort S86 0) +(declare-sort S87 0) +(declare-sort S88 0) +(declare-sort S89 0) +(declare-sort S90 0) +(declare-sort S91 0) +(declare-sort S92 0) +(declare-sort S93 0) +(declare-sort S94 0) +(declare-sort S95 0) +(declare-sort S96 0) +(declare-sort S97 0) +(declare-sort S98 0) +(declare-sort S99 0) +(declare-sort S100 0) +(declare-sort S101 0) +(declare-sort S102 0) +(declare-sort S103 0) +(declare-sort S104 0) +(declare-sort S105 0) +(declare-sort S106 0) +(declare-sort S107 0) +(declare-sort S108 0) +(declare-sort S109 0) +(declare-sort S110 0) +(declare-sort S111 0) +(declare-sort S112 0) +(declare-sort S113 0) +(declare-sort S114 0) +(declare-sort S115 0) +(declare-sort S116 0) +(declare-sort S117 0) +(declare-sort S118 0) +(declare-sort S119 0) +(declare-sort S120 0) +(declare-sort S121 0) +(declare-sort S122 0) +(declare-sort S123 0) +(declare-sort S124 0) +(declare-sort S125 0) +(declare-sort S126 0) +(declare-sort S127 0) +(declare-sort S128 0) +(declare-sort S129 0) +(declare-sort S130 0) +(declare-sort S131 0) +(declare-sort S132 0) +(declare-sort S133 0) +(declare-sort S134 0) +(declare-sort S135 0) +(declare-sort S136 0) +(declare-sort S137 0) +(declare-sort S138 0) +(declare-sort S139 0) +(declare-sort S140 0) +(declare-sort S141 0) +(declare-sort S142 0) +(declare-sort S143 0) +(declare-sort S144 0) +(declare-sort S145 0) +(declare-sort S146 0) +(declare-sort S147 0) +(declare-sort S148 0) +(declare-sort S149 0) +(declare-sort S150 0) +(declare-sort S151 0) +(declare-sort S152 0) +(declare-sort S153 0) +(declare-sort S154 0) +(declare-sort S155 0) +(declare-sort S156 0) +(declare-sort S157 0) +(declare-sort S158 0) +(declare-sort S159 0) +(declare-sort S160 0) +(declare-sort S161 0) +(declare-sort S162 0) +(declare-sort S163 0) +(declare-sort S164 0) +(declare-sort S165 0) +(declare-sort S166 0) +(declare-sort S167 0) +(declare-sort S168 0) +(declare-sort S169 0) +(declare-sort S170 0) +(declare-sort S171 0) +(declare-sort S172 0) +(declare-sort S173 0) +(declare-sort S174 0) +(declare-sort S175 0) +(declare-sort S176 0) +(declare-sort S177 0) +(declare-sort S178 0) +(declare-sort S179 0) +(declare-sort S180 0) +(declare-sort S181 0) +(declare-sort S182 0) +(declare-sort S183 0) +(declare-sort S184 0) +(declare-sort S185 0) +(declare-fun f1 () S1) +(declare-fun f2 () S1) +(declare-fun f3 (Int) S1) +(declare-fun f4 () Int) +(declare-fun f5 () Int) +(declare-fun f6 (S2 S3) Int) +(declare-fun f7 () S2) +(declare-fun f8 (S4 Int) S3) +(declare-fun f9 (S5 Int) S4) +(declare-fun f10 () S5) +(declare-fun f11 (S6 S7) S1) +(declare-fun f12 (S9 S8) S7) +(declare-fun f13 (S10 S8) S9) +(declare-fun f14 () S10) +(declare-fun f15 (S11 S12) S1) +(declare-fun f16 (S13 S3) S12) +(declare-fun f17 (S14 S3) S13) +(declare-fun f18 () S14) +(declare-fun f19 (S15 S3) S1) +(declare-fun f20 (S16 S17) S1) +(declare-fun f21 (S19 S18) S17) +(declare-fun f22 (S20 S18) S19) +(declare-fun f23 () S20) +(declare-fun f24 (S21 S8) S1) +(declare-fun f25 (S22 S17) S8) +(declare-fun f26 (S23 S17) S22) +(declare-fun f27 () S23) +(declare-fun f28 (S24 S8) S21) +(declare-fun f29 (S6) S24) +(declare-fun f30 (S7 S6) S1) +(declare-fun f31 (S25 S3) S15) +(declare-fun f32 (S11) S25) +(declare-fun f33 (S12 S11) S1) +(declare-fun f34 (S26 Int) S1) +(declare-fun f35 (S27 Int) S26) +(declare-fun f36 (S15) S27) +(declare-fun f37 (S3 S15) S1) +(declare-fun f38 (S28 S18) S1) +(declare-fun f39 (S29 S18) S28) +(declare-fun f40 (S16) S29) +(declare-fun f41 (S17 S16) S1) +(declare-fun f42 (S30 S17) S16) +(declare-fun f43 (S21) S30) +(declare-fun f44 (S8 S21) S1) +(declare-fun f45 (S31 S8) S6) +(declare-fun f46 (S32 S33) S1) +(declare-fun f47 (S7 S7) S32) +(declare-fun f48 (S34 S31) S33) +(declare-fun f49 (S21) S34) +(declare-fun f50 (S35 S3) S11) +(declare-fun f51 (S36 S37) S1) +(declare-fun f52 (S12 S12) S36) +(declare-fun f53 (S38 S35) S37) +(declare-fun f54 (S15) S38) +(declare-fun f55 (S39 Int) S15) +(declare-fun f56 (S40 S39) S11) +(declare-fun f57 (S26) S40) +(declare-fun f58 (S41 S17) S21) +(declare-fun f59 (S42 S41) S6) +(declare-fun f60 (S16) S42) +(declare-fun f61 (S43 S18) S16) +(declare-fun f62 (S44 S43) S21) +(declare-fun f63 (S28) S44) +(declare-fun f64 (S6) S1) +(declare-fun f65 (S11) S1) +(declare-fun f66 (S15) S1) +(declare-fun f67 (S16) S1) +(declare-fun f68 (S21) S1) +(declare-fun f69 (S6) S1) +(declare-fun f70 (S11) S1) +(declare-fun f71 (S15) S1) +(declare-fun f72 (S16) S1) +(declare-fun f73 (S21) S1) +(declare-fun f74 (S6) S24) +(declare-fun f75 (S11) S25) +(declare-fun f76 (S15) S27) +(declare-fun f77 (S16) S29) +(declare-fun f78 (S21) S30) +(declare-fun f79 (S45 S6) S33) +(declare-fun f80 (S6) S45) +(declare-fun f81 (S46 S11) S37) +(declare-fun f82 (S11) S46) +(declare-fun f83 (S47 S15) S11) +(declare-fun f84 (S15) S47) +(declare-fun f85 (S48 S21) S6) +(declare-fun f86 (S21) S48) +(declare-fun f87 (S49 S50) S1) +(declare-fun f88 (S51 S51) S49) +(declare-fun f89 (Int S8) S51) +(declare-fun f90 (S15 S6) S50) +(declare-fun f91 (S52 S53) S1) +(declare-fun f92 (S54 S54) S52) +(declare-fun f93 (Int S3) S54) +(declare-fun f94 (S15 S11) S53) +(declare-fun f95 (S55 S56) S1) +(declare-fun f96 (S57 S57) S55) +(declare-fun f97 (S8 Int) S57) +(declare-fun f98 (S6 S15) S56) +(declare-fun f99 (S58 S59) S1) +(declare-fun f100 (S60 S60) S58) +(declare-fun f101 (S3 Int) S60) +(declare-fun f102 (S11 S15) S59) +(declare-fun f103 (S61 S16) S21) +(declare-fun f104 (S16) S61) +(declare-fun f105 (S62 S63) S1) +(declare-fun f106 (S64 S64) S62) +(declare-fun f107 (S18 Int) S64) +(declare-fun f108 (S16 S15) S63) +(declare-fun f109 (S65 S66) S1) +(declare-fun f110 (S67 S67) S65) +(declare-fun f111 (S18 S8) S67) +(declare-fun f112 (S16 S6) S66) +(declare-fun f113 (S68 S69) S1) +(declare-fun f114 (S70 S70) S68) +(declare-fun f115 (S18 S3) S70) +(declare-fun f116 (S16 S11) S69) +(declare-fun f117 (S71 S72) S1) +(declare-fun f118 (S73 S73) S71) +(declare-fun f119 (S17 Int) S73) +(declare-fun f120 (S21 S15) S72) +(declare-fun f121 (S74 S75) S1) +(declare-fun f122 (S76 S76) S74) +(declare-fun f123 (S17 S8) S76) +(declare-fun f124 (S21 S6) S75) +(declare-fun f125 (S77 S78) S1) +(declare-fun f126 (S79 S79) S77) +(declare-fun f127 (S17 S3) S79) +(declare-fun f128 (S21 S11) S78) +(declare-fun f129 (S80 S81) S1) +(declare-fun f130 (S82 S82) S80) +(declare-fun f131 (Int S18) S82) +(declare-fun f132 (S15 S16) S81) +(declare-fun f133 (S83 S84) S1) +(declare-fun f134 (S85 S85) S83) +(declare-fun f135 (S8 S18) S85) +(declare-fun f136 (S6 S16) S84) +(declare-fun f137 (S86 S87) S1) +(declare-fun f138 (S88 S88) S86) +(declare-fun f139 (S3 S18) S88) +(declare-fun f140 (S11 S16) S87) +(declare-fun f141 (S89 S90) S1) +(declare-fun f142 (S91 S91) S89) +(declare-fun f143 (Int S17) S91) +(declare-fun f144 (S15 S21) S90) +(declare-fun f145 (S92 S93) S1) +(declare-fun f146 (S94 S94) S92) +(declare-fun f147 (S8 S17) S94) +(declare-fun f148 (S6 S21) S93) +(declare-fun f149 (S95 S96) S1) +(declare-fun f150 (S97 S97) S95) +(declare-fun f151 (S3 S17) S97) +(declare-fun f152 (S11 S21) S96) +(declare-fun f153 (S98) S6) +(declare-fun f154 (S99 S18) Int) +(declare-fun f155 () S99) +(declare-fun f156 (S98 S8) S18) +(declare-fun f157 (S100) S11) +(declare-fun f158 (S100 S3) S18) +(declare-fun f159 (S101) S15) +(declare-fun f160 (S101 Int) S18) +(declare-fun f161 (S102) S16) +(declare-fun f162 (S102 S18) S18) +(declare-fun f163 (S103) S21) +(declare-fun f164 (S103 S17) S18) +(declare-fun f165 (S104 S6) S6) +(declare-fun f166 (S98) S104) +(declare-fun f167 (S105 S11) S11) +(declare-fun f168 (S100) S105) +(declare-fun f169 (S106 S15) S15) +(declare-fun f170 (S101) S106) +(declare-fun f171 (S107 S16) S16) +(declare-fun f172 (S102) S107) +(declare-fun f173 (S108 S21) S21) +(declare-fun f174 (S103) S108) +(declare-fun f175 (S15 S11) S1) +(declare-fun f176 (S6 S33) S1) +(declare-fun f177 (S11 S37) S1) +(declare-fun f178 (S26 S15) S1) +(declare-fun f179 (Int S26) S1) +(declare-fun f180 (S21 S6) S1) +(declare-fun f181 (S28 S16) S1) +(declare-fun f182 (S18 S28) S1) +(declare-fun f183 (S16 S21) S1) +(declare-fun f184 () S109) +(declare-fun f185 () S109) +(declare-fun f186 () S110) +(declare-fun f187 () S110) +(declare-fun f188 () S111) +(declare-fun f189 () S111) +(declare-fun f190 (S113 S112) S15) +(declare-fun f191 (S6) S113) +(declare-fun f192 (S112 Int) S8) +(declare-fun f193 (S114 S4) S15) +(declare-fun f194 (S11) S114) +(declare-fun f195 (S116 S115) S15) +(declare-fun f196 (S15) S116) +(declare-fun f197 (S115 Int) Int) +(declare-fun f198 (S118 S117) S6) +(declare-fun f199 (S15) S118) +(declare-fun f200 (S117 S8) Int) +(declare-fun f201 (S119 S2) S11) +(declare-fun f202 (S15) S119) +(declare-fun f203 (S120 S99) S16) +(declare-fun f204 (S15) S120) +(declare-fun f205 (S122 S121) S16) +(declare-fun f206 (S6) S122) +(declare-fun f207 (S121 S18) S8) +(declare-fun f208 (S124 S123) S16) +(declare-fun f209 (S11) S124) +(declare-fun f210 (S123 S18) S3) +(declare-fun f211 (S126 S125) S21) +(declare-fun f212 (S15) S126) +(declare-fun f213 (S125 S17) Int) +(declare-fun f214 (S127 S22) S21) +(declare-fun f215 (S6) S127) +(declare-fun f216 (S129 S128) S21) +(declare-fun f217 (S11) S129) +(declare-fun f218 (S128 S17) S3) +(declare-fun f219 (S130 S101) S15) +(declare-fun f220 (S16) S130) +(declare-fun f221 (S131 S98) S6) +(declare-fun f222 (S16) S131) +(declare-fun f223 (S132 S100) S11) +(declare-fun f224 (S16) S132) +(declare-fun f225 (S134 S133) S15) +(declare-fun f226 (S21) S134) +(declare-fun f227 (S133 Int) S17) +(declare-fun f228 (S136 S135) S6) +(declare-fun f229 (S21) S136) +(declare-fun f230 (S135 S8) S17) +(declare-fun f231 (S138 S137) S11) +(declare-fun f232 (S21) S138) +(declare-fun f233 (S137 S3) S17) +(declare-fun f234 (S24) S6) +(declare-fun f235 (S25) S11) +(declare-fun f236 (S111 S27) S15) +(declare-fun f237 (S110 S29) S16) +(declare-fun f238 (S109 S30) S21) +(declare-fun f239 (S139 Int) S39) +(declare-fun f240 (S139) S25) +(declare-fun f241 (S141 Int) S6) +(declare-fun f242 (S140 Int) S141) +(declare-fun f243 (S142 S3) S6) +(declare-fun f244 (S140) S142) +(declare-fun f245 (S144 Int) S11) +(declare-fun f246 (S143 Int) S144) +(declare-fun f247 (S143) S35) +(declare-fun f248 (S146 Int) S28) +(declare-fun f249 (S145 Int) S146) +(declare-fun f250 (S147 S3) S28) +(declare-fun f251 (S145) S147) +(declare-fun f252 (S148 Int) S27) +(declare-fun f253 (S149 S3) S26) +(declare-fun f254 (S148) S149) +(declare-fun f255 (S151 S18) S15) +(declare-fun f256 (S150 S18) S151) +(declare-fun f257 (S152 S17) S15) +(declare-fun f258 (S150) S152) +(declare-fun f259 (S154 S18) S6) +(declare-fun f260 (S153 S18) S154) +(declare-fun f261 (S155 S17) S6) +(declare-fun f262 (S153) S155) +(declare-fun f263 (S157 S18) S11) +(declare-fun f264 (S156 S18) S157) +(declare-fun f265 (S158 S17) S11) +(declare-fun f266 (S156) S158) +(declare-fun f267 (S159 S18) S29) +(declare-fun f268 (S160 S17) S28) +(declare-fun f269 (S159) S160) +(declare-fun f270 (S162 S18) S26) +(declare-fun f271 (S161 S18) S162) +(declare-fun f272 (S163 S17) S26) +(declare-fun f273 (S161) S163) +(declare-fun f274 (S164 S17) S152) +(declare-fun f275 (S165 S8) S15) +(declare-fun f276 (S164) S165) +(declare-fun f277 (S166 S17) S155) +(declare-fun f278 (S166) S31) +(declare-fun f279 (S167 S17) S158) +(declare-fun f280 (S168 S8) S11) +(declare-fun f281 (S167) S168) +(declare-fun f282 (S169 S17) S160) +(declare-fun f283 (S170 S8) S28) +(declare-fun f284 (S169) S170) +(declare-fun f285 (S171 S17) S163) +(declare-fun f286 (S172 S8) S26) +(declare-fun f287 (S171) S172) +(declare-fun f288 (S174 S8) S16) +(declare-fun f289 (S173 S8) S174) +(declare-fun f290 (S175 S7) S16) +(declare-fun f291 (S173) S175) +(declare-fun f292 (S177 S3) S16) +(declare-fun f293 (S176 S3) S177) +(declare-fun f294 (S178 S12) S16) +(declare-fun f295 (S176) S178) +(declare-fun f296 (S179 S8) S24) +(declare-fun f297 (S180 S7) S21) +(declare-fun f298 (S179) S180) +(declare-fun f299 (S182 S3) S21) +(declare-fun f300 (S181 S3) S182) +(declare-fun f301 (S183 S12) S21) +(declare-fun f302 (S181) S183) +(declare-fun f303 () S16) +(declare-fun f304 () S21) +(declare-fun f305 (S16) S1) +(declare-fun f306 (S21) S1) +(declare-fun f307 (S16) S1) +(declare-fun f308 (S21) S1) +(declare-fun f309 (S16) S1) +(declare-fun f310 (S15) S1) +(declare-fun f311 (S21) S1) +(declare-fun f312 (S15) S1) +(declare-fun f313 (S15) S1) +(declare-fun f314 (S6) S1) +(declare-fun f315 () S101) +(declare-fun f316 (S30) S1) +(declare-fun f317 (S29) S1) +(declare-fun f318 (S24) S1) +(declare-fun f319 () S16) +(declare-fun f320 () S21) +(declare-fun f321 (S184) S1) +(declare-fun f322 (S21) S184) +(declare-fun f323 (S185) S1) +(declare-fun f324 (S16) S185) +(declare-fun f325 (S16) S16) +(declare-fun f326 (S21) S21) +(declare-fun f327 (S15) S15) +(declare-fun f328 (S21) S184) +(declare-fun f329 (S16) S185) +(declare-fun f330 (S6) S6) +(declare-fun f331 (S11) S11) +(assert (not (= f1 f2))) +(assert (not (= (f3 (* f4 f5)) f1))) +(assert (= (f3 f4) f1)) +(assert (= (f3 f5) f1)) +(assert (forall ((?v0 Int)) (= (= (f3 ?v0) f1) (exists ((?v1 Int) (?v2 Int)) (= (f6 f7 (f8 (f9 f10 ?v1) ?v2)) ?v0))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (* (f6 f7 (f8 (f9 f10 ?v0) ?v1)) (f6 f7 (f8 (f9 f10 ?v2) ?v3))) (f6 f7 (f8 (f9 f10 (+ (* ?v0 ?v2) (* ?v1 ?v3))) (- (* ?v0 ?v3) (* ?v1 ?v2))))))) +(assert (forall ((?v0 S6)) (= (forall ((?v1 S7)) (= (f11 ?v0 ?v1) f1)) (forall ((?v1 S8) (?v2 S8)) (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S11)) (= (forall ((?v1 S12)) (= (f15 ?v0 ?v1) f1)) (forall ((?v1 S3) (?v2 S3)) (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S15)) (= (forall ((?v1 S3)) (= (f19 ?v0 ?v1) f1)) (forall ((?v1 Int) (?v2 Int)) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S16)) (= (forall ((?v1 S17)) (= (f20 ?v0 ?v1) f1)) (forall ((?v1 S18) (?v2 S18)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S21)) (= (forall ((?v1 S8)) (= (f24 ?v0 ?v1) f1)) (forall ((?v1 S17) (?v2 S17)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S8) (?v3 S8)) (= (= (f12 (f13 f14 ?v0) ?v1) (f12 (f13 f14 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (= (= (f16 (f17 f18 ?v0) ?v1) (f16 (f17 f18 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (= (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17)) (= (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S8) (?v3 S8)) (=> (= (f12 (f13 f14 ?v0) ?v1) (f12 (f13 f14 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (=> (= (f16 (f17 f18 ?v0) ?v1) (f16 (f17 f18 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (=> (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17)) (=> (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (= (= (f24 (f28 (f29 ?v0) ?v1) ?v2) f1) (= (f30 (f12 (f13 f14 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (= (= (f19 (f31 (f32 ?v0) ?v1) ?v2) f1) (= (f33 (f16 (f17 f18 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (= (= (f34 (f35 (f36 ?v0) ?v1) ?v2) f1) (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (= (= (f38 (f39 (f40 ?v0) ?v1) ?v2) f1) (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (= (= (f20 (f42 (f43 ?v0) ?v1) ?v2) f1) (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S8) (?v2 S8) (?v3 S8) (?v4 S31)) (let ((?v_0 (f13 f14 ?v1))) (=> (= (f24 ?v0 ?v1) f1) (=> (= (f30 (f12 (f13 f14 ?v2) ?v3) (f45 ?v4 ?v1)) f1) (= (f46 (f47 (f12 ?v_0 ?v2) (f12 ?v_0 ?v3)) (f48 (f49 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S15) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S35)) (let ((?v_0 (f17 f18 ?v1))) (=> (= (f19 ?v0 ?v1) f1) (=> (= (f33 (f16 (f17 f18 ?v2) ?v3) (f50 ?v4 ?v1)) f1) (= (f51 (f52 (f16 ?v_0 ?v2) (f16 ?v_0 ?v3)) (f53 (f54 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S26) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S39)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f34 ?v0 ?v1) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) (f55 ?v4 ?v1)) f1) (= (f33 (f16 (f17 f18 (f8 ?v_0 ?v2)) (f8 ?v_0 ?v3)) (f56 (f57 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S16) (?v1 S17) (?v2 S17) (?v3 S17) (?v4 S41)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f20 ?v0 ?v1) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) (f58 ?v4 ?v1)) f1) (= (f30 (f12 (f13 f14 (f25 ?v_0 ?v2)) (f25 ?v_0 ?v3)) (f59 (f60 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S28) (?v1 S18) (?v2 S18) (?v3 S18) (?v4 S43)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f38 ?v0 ?v1) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) (f61 ?v4 ?v1)) f1) (= (f44 (f25 (f26 f27 (f21 ?v_0 ?v2)) (f21 ?v_0 ?v3)) (f62 (f63 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6)) (= (= (f64 ?v0) f1) (forall ((?v1 S8)) (= (f30 (f12 (f13 f14 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S11)) (= (= (f65 ?v0) f1) (forall ((?v1 S3)) (= (f33 (f16 (f17 f18 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S15)) (= (= (f66 ?v0) f1) (forall ((?v1 Int)) (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S16)) (= (= (f67 ?v0) f1) (forall ((?v1 S18)) (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S21)) (= (= (f68 ?v0) f1) (forall ((?v1 S17)) (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S6)) (= (= (f69 ?v0) f1) (forall ((?v1 S8)) (not (= (f30 (f12 (f13 f14 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S11)) (= (= (f70 ?v0) f1) (forall ((?v1 S3)) (not (= (f33 (f16 (f17 f18 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S15)) (= (= (f71 ?v0) f1) (forall ((?v1 Int)) (not (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S16)) (= (= (f72 ?v0) f1) (forall ((?v1 S18)) (not (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S21)) (= (= (f73 ?v0) f1) (forall ((?v1 S17)) (not (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S6)) (= (exists ((?v1 S7)) (= (f11 ?v0 ?v1) f1)) (exists ((?v1 S8) (?v2 S8)) (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S11)) (= (exists ((?v1 S12)) (= (f15 ?v0 ?v1) f1)) (exists ((?v1 S3) (?v2 S3)) (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S15)) (= (exists ((?v1 S3)) (= (f19 ?v0 ?v1) f1)) (exists ((?v1 Int) (?v2 Int)) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S16)) (= (exists ((?v1 S17)) (= (f20 ?v0 ?v1) f1)) (exists ((?v1 S18) (?v2 S18)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S21)) (= (exists ((?v1 S8)) (= (f24 ?v0 ?v1) f1)) (exists ((?v1 S17) (?v2 S17)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S17) (?v3 S18) (?v4 S18)) (=> (= ?v0 (f12 (f13 f14 ?v1) (f25 (f26 f27 ?v2) (f21 (f22 f23 ?v3) ?v4)))) false)) false))) +(assert (forall ((?v0 S6) (?v1 S7)) (=> (forall ((?v2 S8) (?v3 S17) (?v4 S18) (?v5 S18)) (= (f11 ?v0 (f12 (f13 f14 ?v2) (f25 (f26 f27 ?v3) (f21 (f22 f23 ?v4) ?v5)))) f1)) (= (f11 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S17) (?v2 S18) (?v3 S18)) (=> (= ?v0 (f25 (f26 f27 ?v1) (f21 (f22 f23 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S12)) (=> (forall ((?v1 S3) (?v2 Int) (?v3 Int)) (=> (= ?v0 (f16 (f17 f18 ?v1) (f8 (f9 f10 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S17) (?v3 S17)) (=> (= ?v0 (f12 (f13 f14 ?v1) (f25 (f26 f27 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S21) (?v1 S8)) (=> (forall ((?v2 S17) (?v3 S18) (?v4 S18)) (= (f24 ?v0 (f25 (f26 f27 ?v2) (f21 (f22 f23 ?v3) ?v4))) f1)) (= (f24 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S11) (?v1 S12)) (=> (forall ((?v2 S3) (?v3 Int) (?v4 Int)) (= (f15 ?v0 (f16 (f17 f18 ?v2) (f8 (f9 f10 ?v3) ?v4))) f1)) (= (f15 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S6) (?v1 S7)) (=> (forall ((?v2 S8) (?v3 S17) (?v4 S17)) (= (f11 ?v0 (f12 (f13 f14 ?v2) (f25 (f26 f27 ?v3) ?v4))) f1)) (= (f11 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S8)) (=> (= ?v0 (f12 (f13 f14 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S12)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f16 (f17 f18 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S17)) (=> (forall ((?v1 S18) (?v2 S18)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S17) (?v2 S17)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S8)) (=> (= ?v0 (f12 (f13 f14 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S12)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f16 (f17 f18 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S17)) (=> (forall ((?v1 S18) (?v2 S18)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S17) (?v2 S17)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (=> (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1) (= (f24 (f28 (f74 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (=> (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1) (= (f19 (f31 (f75 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S8) (?v3 S8) (?v4 S6) (?v5 S6)) (let ((?v_0 (f13 f14 ?v0))) (= (= (f46 (f47 (f12 ?v_0 ?v1) (f12 (f13 f14 ?v2) ?v3)) (f79 (f80 ?v4) ?v5)) f1) (or (= (f30 (f12 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S11) (?v5 S11)) (let ((?v_0 (f17 f18 ?v0))) (= (= (f51 (f52 (f16 ?v_0 ?v1) (f16 (f17 f18 ?v2) ?v3)) (f81 (f82 ?v4) ?v5)) f1) (or (= (f33 (f16 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S15) (?v5 S15)) (let ((?v_0 (f9 f10 ?v0))) (= (= (f33 (f16 (f17 f18 (f8 ?v_0 ?v1)) (f8 (f9 f10 ?v2) ?v3)) (f83 (f84 ?v4) ?v5)) f1) (or (= (f37 (f8 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17) (?v4 S21) (?v5 S21)) (let ((?v_0 (f26 f27 ?v0))) (= (= (f30 (f12 (f13 f14 (f25 ?v_0 ?v1)) (f25 (f26 f27 ?v2) ?v3)) (f85 (f86 ?v4) ?v5)) f1) (or (= (f44 (f25 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 Int) (?v1 S8) (?v2 Int) (?v3 S8) (?v4 S15) (?v5 S6)) (= (= (f87 (f88 (f89 ?v0 ?v1) (f89 ?v2 ?v3)) (f90 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3) (?v4 S15) (?v5 S11)) (= (= (f91 (f92 (f93 ?v0 ?v1) (f93 ?v2 ?v3)) (f94 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S8) (?v1 Int) (?v2 S8) (?v3 Int) (?v4 S6) (?v5 S15)) (= (= (f95 (f96 (f97 ?v0 ?v1) (f97 ?v2 ?v3)) (f98 ?v4 ?v5)) f1) (or (= (f30 (f12 (f13 f14 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int) (?v4 S11) (?v5 S15)) (= (= (f99 (f100 (f101 ?v0 ?v1) (f101 ?v2 ?v3)) (f102 ?v4 ?v5)) f1) (or (= (f33 (f16 (f17 f18 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18) (?v4 S16) (?v5 S16)) (let ((?v_0 (f22 f23 ?v0))) (= (= (f44 (f25 (f26 f27 (f21 ?v_0 ?v1)) (f21 (f22 f23 ?v2) ?v3)) (f103 (f104 ?v4) ?v5)) f1) (or (= (f41 (f21 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S18) (?v1 Int) (?v2 S18) (?v3 Int) (?v4 S16) (?v5 S15)) (= (= (f105 (f106 (f107 ?v0 ?v1) (f107 ?v2 ?v3)) (f108 ?v4 ?v5)) f1) (or (= (f41 (f21 (f22 f23 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S18) (?v1 S8) (?v2 S18) (?v3 S8) (?v4 S16) (?v5 S6)) (= (= (f109 (f110 (f111 ?v0 ?v1) (f111 ?v2 ?v3)) (f112 ?v4 ?v5)) f1) (or (= (f41 (f21 (f22 f23 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S18) (?v1 S3) (?v2 S18) (?v3 S3) (?v4 S16) (?v5 S11)) (= (= (f113 (f114 (f115 ?v0 ?v1) (f115 ?v2 ?v3)) (f116 ?v4 ?v5)) f1) (or (= (f41 (f21 (f22 f23 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S17) (?v3 Int) (?v4 S21) (?v5 S15)) (= (= (f117 (f118 (f119 ?v0 ?v1) (f119 ?v2 ?v3)) (f120 ?v4 ?v5)) f1) (or (= (f44 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S17) (?v1 S8) (?v2 S17) (?v3 S8) (?v4 S21) (?v5 S6)) (= (= (f121 (f122 (f123 ?v0 ?v1) (f123 ?v2 ?v3)) (f124 ?v4 ?v5)) f1) (or (= (f44 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S17) (?v1 S3) (?v2 S17) (?v3 S3) (?v4 S21) (?v5 S11)) (= (= (f125 (f126 (f127 ?v0 ?v1) (f127 ?v2 ?v3)) (f128 ?v4 ?v5)) f1) (or (= (f44 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S18) (?v2 Int) (?v3 S18) (?v4 S15) (?v5 S16)) (= (= (f129 (f130 (f131 ?v0 ?v1) (f131 ?v2 ?v3)) (f132 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S8) (?v1 S18) (?v2 S8) (?v3 S18) (?v4 S6) (?v5 S16)) (= (= (f133 (f134 (f135 ?v0 ?v1) (f135 ?v2 ?v3)) (f136 ?v4 ?v5)) f1) (or (= (f30 (f12 (f13 f14 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 S18) (?v2 S3) (?v3 S18) (?v4 S11) (?v5 S16)) (= (= (f137 (f138 (f139 ?v0 ?v1) (f139 ?v2 ?v3)) (f140 ?v4 ?v5)) f1) (or (= (f33 (f16 (f17 f18 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S17) (?v2 Int) (?v3 S17) (?v4 S15) (?v5 S21)) (= (= (f141 (f142 (f143 ?v0 ?v1) (f143 ?v2 ?v3)) (f144 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S8) (?v1 S17) (?v2 S8) (?v3 S17) (?v4 S6) (?v5 S21)) (= (= (f145 (f146 (f147 ?v0 ?v1) (f147 ?v2 ?v3)) (f148 ?v4 ?v5)) f1) (or (= (f30 (f12 (f13 f14 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 S17) (?v2 S3) (?v3 S17) (?v4 S11) (?v5 S21)) (= (= (f149 (f150 (f151 ?v0 ?v1) (f151 ?v2 ?v3)) (f152 ?v4 ?v5)) f1) (or (= (f33 (f16 (f17 f18 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (= (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (= (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (= (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 (f74 ?v0) ?v1) ?v2) f1) (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 (f75 ?v0) ?v1) ?v2) f1) (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 (f74 ?v0) ?v1) ?v2) f1) (=> (=> (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 (f75 ?v0) ?v1) ?v2) f1) (=> (=> (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1) (=> (=> (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1) (=> (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1) (=> (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S98)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f153 ?v2)) f1) (< (f154 f155 (f156 ?v2 ?v0)) (f154 f155 (f156 ?v2 ?v1)))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S100)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f157 ?v2)) f1) (< (f154 f155 (f158 ?v2 ?v0)) (f154 f155 (f158 ?v2 ?v1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S101)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f159 ?v2)) f1) (< (f154 f155 (f160 ?v2 ?v0)) (f154 f155 (f160 ?v2 ?v1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S102)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f161 ?v2)) f1) (< (f154 f155 (f162 ?v2 ?v0)) (f154 f155 (f162 ?v2 ?v1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S103)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f163 ?v2)) f1) (< (f154 f155 (f164 ?v2 ?v0)) (f154 f155 (f164 ?v2 ?v1)))))) +(assert (forall ((?v0 S98) (?v1 S8) (?v2 S8) (?v3 S6)) (=> (< (f154 f155 (f156 ?v0 ?v1)) (f154 f155 (f156 ?v0 ?v2))) (= (f30 (f12 (f13 f14 ?v1) ?v2) (f165 (f166 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S100) (?v1 S3) (?v2 S3) (?v3 S11)) (=> (< (f154 f155 (f158 ?v0 ?v1)) (f154 f155 (f158 ?v0 ?v2))) (= (f33 (f16 (f17 f18 ?v1) ?v2) (f167 (f168 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S101) (?v1 Int) (?v2 Int) (?v3 S15)) (=> (< (f154 f155 (f160 ?v0 ?v1)) (f154 f155 (f160 ?v0 ?v2))) (= (f37 (f8 (f9 f10 ?v1) ?v2) (f169 (f170 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S102) (?v1 S18) (?v2 S18) (?v3 S16)) (=> (< (f154 f155 (f162 ?v0 ?v1)) (f154 f155 (f162 ?v0 ?v2))) (= (f41 (f21 (f22 f23 ?v1) ?v2) (f171 (f172 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S103) (?v1 S17) (?v2 S17) (?v3 S21)) (=> (< (f154 f155 (f164 ?v0 ?v1)) (f154 f155 (f164 ?v0 ?v2))) (= (f44 (f25 (f26 f27 ?v1) ?v2) (f173 (f174 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S98) (?v1 S8) (?v2 S8) (?v3 S6)) (let ((?v_0 (f12 (f13 f14 ?v1) ?v2))) (=> (<= (f154 f155 (f156 ?v0 ?v1)) (f154 f155 (f156 ?v0 ?v2))) (=> (= (f30 ?v_0 ?v3) f1) (= (f30 ?v_0 (f165 (f166 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S100) (?v1 S3) (?v2 S3) (?v3 S11)) (let ((?v_0 (f16 (f17 f18 ?v1) ?v2))) (=> (<= (f154 f155 (f158 ?v0 ?v1)) (f154 f155 (f158 ?v0 ?v2))) (=> (= (f33 ?v_0 ?v3) f1) (= (f33 ?v_0 (f167 (f168 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S101) (?v1 Int) (?v2 Int) (?v3 S15)) (let ((?v_0 (f8 (f9 f10 ?v1) ?v2))) (=> (<= (f154 f155 (f160 ?v0 ?v1)) (f154 f155 (f160 ?v0 ?v2))) (=> (= (f37 ?v_0 ?v3) f1) (= (f37 ?v_0 (f169 (f170 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S102) (?v1 S18) (?v2 S18) (?v3 S16)) (let ((?v_0 (f21 (f22 f23 ?v1) ?v2))) (=> (<= (f154 f155 (f162 ?v0 ?v1)) (f154 f155 (f162 ?v0 ?v2))) (=> (= (f41 ?v_0 ?v3) f1) (= (f41 ?v_0 (f171 (f172 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S103) (?v1 S17) (?v2 S17) (?v3 S21)) (let ((?v_0 (f25 (f26 f27 ?v1) ?v2))) (=> (<= (f154 f155 (f164 ?v0 ?v1)) (f154 f155 (f164 ?v0 ?v2))) (=> (= (f44 ?v_0 ?v3) f1) (= (f44 ?v_0 (f173 (f174 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S15) (?v1 S11)) (= (= (f175 ?v0 ?v1) f1) (forall ((?v2 S3)) (=> (= (f37 ?v2 ?v0) f1) (forall ((?v3 S3)) (=> (= (f37 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f33 (f16 (f17 f18 ?v2) ?v3) ?v1) f1) (= (f33 (f16 (f17 f18 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S6) (?v1 S33)) (= (= (f176 ?v0 ?v1) f1) (forall ((?v2 S7)) (=> (= (f30 ?v2 ?v0) f1) (forall ((?v3 S7)) (=> (= (f30 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f46 (f47 ?v2 ?v3) ?v1) f1) (= (f46 (f47 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S11) (?v1 S37)) (= (= (f177 ?v0 ?v1) f1) (forall ((?v2 S12)) (=> (= (f33 ?v2 ?v0) f1) (forall ((?v3 S12)) (=> (= (f33 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f51 (f52 ?v2 ?v3) ?v1) f1) (= (f51 (f52 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S26) (?v1 S15)) (= (= (f178 ?v0 ?v1) f1) (forall ((?v2 Int)) (=> (= (f179 ?v2 ?v0) f1) (forall ((?v3 Int)) (=> (= (f179 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v1) f1) (= (f37 (f8 (f9 f10 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S21) (?v1 S6)) (= (= (f180 ?v0 ?v1) f1) (forall ((?v2 S8)) (=> (= (f44 ?v2 ?v0) f1) (forall ((?v3 S8)) (=> (= (f44 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f30 (f12 (f13 f14 ?v2) ?v3) ?v1) f1) (= (f30 (f12 (f13 f14 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S28) (?v1 S16)) (= (= (f181 ?v0 ?v1) f1) (forall ((?v2 S18)) (=> (= (f182 ?v2 ?v0) f1) (forall ((?v3 S18)) (=> (= (f182 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v1) f1) (= (f41 (f21 (f22 f23 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S16) (?v1 S21)) (= (= (f183 ?v0 ?v1) f1) (forall ((?v2 S17)) (=> (= (f41 ?v2 ?v0) f1) (forall ((?v3 S17)) (=> (= (f41 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v1) f1) (= (f44 (f25 (f26 f27 ?v3) ?v2) ?v1) f1)))))))))) +(assert (= f184 f185)) +(assert (= f186 f187)) +(assert (= f188 f189)) +(assert (forall ((?v0 S7)) (exists ((?v1 S8) (?v2 S8)) (= ?v0 (f12 (f13 f14 ?v1) ?v2))))) +(assert (forall ((?v0 S12)) (exists ((?v1 S3) (?v2 S3)) (= ?v0 (f16 (f17 f18 ?v1) ?v2))))) +(assert (forall ((?v0 S3)) (exists ((?v1 Int) (?v2 Int)) (= ?v0 (f8 (f9 f10 ?v1) ?v2))))) +(assert (forall ((?v0 S17)) (exists ((?v1 S18) (?v2 S18)) (= ?v0 (f21 (f22 f23 ?v1) ?v2))))) +(assert (forall ((?v0 S8)) (exists ((?v1 S17) (?v2 S17)) (= ?v0 (f25 (f26 f27 ?v1) ?v2))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S6) (?v3 S112)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f190 (f191 ?v2) ?v3)) f1) (= (f30 (f12 (f13 f14 (f192 ?v3 ?v0)) (f192 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S11) (?v3 S4)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f193 (f194 ?v2) ?v3)) f1) (= (f33 (f16 (f17 f18 (f8 ?v3 ?v0)) (f8 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 S115)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f195 (f196 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f197 ?v3 ?v0)) (f197 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S15) (?v3 S117)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f198 (f199 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f200 ?v3 ?v0)) (f200 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S15) (?v3 S2)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f201 (f202 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f6 ?v3 ?v0)) (f6 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S15) (?v3 S99)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f203 (f204 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f154 ?v3 ?v0)) (f154 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S6) (?v3 S121)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f205 (f206 ?v2) ?v3)) f1) (= (f30 (f12 (f13 f14 (f207 ?v3 ?v0)) (f207 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S11) (?v3 S123)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f208 (f209 ?v2) ?v3)) f1) (= (f33 (f16 (f17 f18 (f210 ?v3 ?v0)) (f210 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S15) (?v3 S125)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f211 (f212 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f213 ?v3 ?v0)) (f213 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S6) (?v3 S22)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f214 (f215 ?v2) ?v3)) f1) (= (f30 (f12 (f13 f14 (f25 ?v3 ?v0)) (f25 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S11) (?v3 S128)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f216 (f217 ?v2) ?v3)) f1) (= (f33 (f16 (f17 f18 (f218 ?v3 ?v0)) (f218 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S16) (?v3 S101)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f219 (f220 ?v2) ?v3)) f1) (= (f41 (f21 (f22 f23 (f160 ?v3 ?v0)) (f160 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S16) (?v3 S98)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f221 (f222 ?v2) ?v3)) f1) (= (f41 (f21 (f22 f23 (f156 ?v3 ?v0)) (f156 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S16) (?v3 S100)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f223 (f224 ?v2) ?v3)) f1) (= (f41 (f21 (f22 f23 (f158 ?v3 ?v0)) (f158 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S21) (?v3 S133)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f225 (f226 ?v2) ?v3)) f1) (= (f44 (f25 (f26 f27 (f227 ?v3 ?v0)) (f227 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S21) (?v3 S135)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f228 (f229 ?v2) ?v3)) f1) (= (f44 (f25 (f26 f27 (f230 ?v3 ?v0)) (f230 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S21) (?v3 S137)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f231 (f232 ?v2) ?v3)) f1) (= (f44 (f25 (f26 f27 (f233 ?v3 ?v0)) (f233 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S24) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 ?v0 ?v1) ?v2) f1) (= (f11 (f234 ?v0) (f12 (f13 f14 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 ?v0 ?v1) ?v2) f1) (= (f15 (f235 ?v0) (f16 (f17 f18 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 ?v0 ?v1) ?v2) f1) (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 ?v0 ?v1) ?v2) f1) (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 ?v0 ?v1) ?v2) f1) (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S24) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 ?v0 ?v1) ?v2) f1) (= (f11 (f234 ?v0) (f12 (f13 f14 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 ?v0 ?v1) ?v2) f1) (= (f15 (f235 ?v0) (f16 (f17 f18 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 ?v0 ?v1) ?v2) f1) (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 ?v0 ?v1) ?v2) f1) (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 ?v0 ?v1) ?v2) f1) (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S3) (?v1 S139) (?v2 Int) (?v3 Int)) (=> (= (f37 ?v0 (f55 (f239 ?v1 ?v2) ?v3)) f1) (= (f37 ?v0 (f31 (f240 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S7) (?v1 S140) (?v2 Int) (?v3 Int)) (=> (= (f30 ?v0 (f241 (f242 ?v1 ?v2) ?v3)) f1) (= (f30 ?v0 (f243 (f244 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S12) (?v1 S143) (?v2 Int) (?v3 Int)) (=> (= (f33 ?v0 (f245 (f246 ?v1 ?v2) ?v3)) f1) (= (f33 ?v0 (f50 (f247 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S18) (?v1 S145) (?v2 Int) (?v3 Int)) (=> (= (f182 ?v0 (f248 (f249 ?v1 ?v2) ?v3)) f1) (= (f182 ?v0 (f250 (f251 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 Int) (?v1 S148) (?v2 Int) (?v3 Int)) (=> (= (f179 ?v0 (f35 (f252 ?v1 ?v2) ?v3)) f1) (= (f179 ?v0 (f253 (f254 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S3) (?v1 S150) (?v2 S18) (?v3 S18)) (=> (= (f37 ?v0 (f255 (f256 ?v1 ?v2) ?v3)) f1) (= (f37 ?v0 (f257 (f258 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S7) (?v1 S153) (?v2 S18) (?v3 S18)) (=> (= (f30 ?v0 (f259 (f260 ?v1 ?v2) ?v3)) f1) (= (f30 ?v0 (f261 (f262 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S12) (?v1 S156) (?v2 S18) (?v3 S18)) (=> (= (f33 ?v0 (f263 (f264 ?v1 ?v2) ?v3)) f1) (= (f33 ?v0 (f265 (f266 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S18) (?v1 S159) (?v2 S18) (?v3 S18)) (=> (= (f182 ?v0 (f39 (f267 ?v1 ?v2) ?v3)) f1) (= (f182 ?v0 (f268 (f269 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 Int) (?v1 S161) (?v2 S18) (?v3 S18)) (=> (= (f179 ?v0 (f270 (f271 ?v1 ?v2) ?v3)) f1) (= (f179 ?v0 (f272 (f273 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S3) (?v1 S164) (?v2 S17) (?v3 S17)) (=> (= (f37 ?v0 (f257 (f274 ?v1 ?v2) ?v3)) f1) (= (f37 ?v0 (f275 (f276 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S7) (?v1 S166) (?v2 S17) (?v3 S17)) (=> (= (f30 ?v0 (f261 (f277 ?v1 ?v2) ?v3)) f1) (= (f30 ?v0 (f45 (f278 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S12) (?v1 S167) (?v2 S17) (?v3 S17)) (=> (= (f33 ?v0 (f265 (f279 ?v1 ?v2) ?v3)) f1) (= (f33 ?v0 (f280 (f281 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S18) (?v1 S169) (?v2 S17) (?v3 S17)) (=> (= (f182 ?v0 (f268 (f282 ?v1 ?v2) ?v3)) f1) (= (f182 ?v0 (f283 (f284 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 Int) (?v1 S171) (?v2 S17) (?v3 S17)) (=> (= (f179 ?v0 (f272 (f285 ?v1 ?v2) ?v3)) f1) (= (f179 ?v0 (f286 (f287 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S17) (?v1 S173) (?v2 S8) (?v3 S8)) (=> (= (f41 ?v0 (f288 (f289 ?v1 ?v2) ?v3)) f1) (= (f41 ?v0 (f290 (f291 ?v1) (f12 (f13 f14 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S17) (?v1 S176) (?v2 S3) (?v3 S3)) (=> (= (f41 ?v0 (f292 (f293 ?v1 ?v2) ?v3)) f1) (= (f41 ?v0 (f294 (f295 ?v1) (f16 (f17 f18 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S8) (?v1 S179) (?v2 S8) (?v3 S8)) (=> (= (f44 ?v0 (f28 (f296 ?v1 ?v2) ?v3)) f1) (= (f44 ?v0 (f297 (f298 ?v1) (f12 (f13 f14 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S8) (?v1 S181) (?v2 S3) (?v3 S3)) (=> (= (f44 ?v0 (f299 (f300 ?v1 ?v2) ?v3)) f1) (= (f44 ?v0 (f301 (f302 ?v1) (f16 (f17 f18 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S30)) (let ((?v_0 (f238 f185 ?v2))) (=> (= ?v0 ?v1) (= (= (f24 ?v_0 ?v0) f1) (= (f24 ?v_0 ?v1) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S29)) (let ((?v_0 (f237 f187 ?v2))) (=> (= ?v0 ?v1) (= (= (f20 ?v_0 ?v0) f1) (= (f20 ?v_0 ?v1) f1)))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S27)) (let ((?v_0 (f236 f189 ?v2))) (=> (= ?v0 ?v1) (= (= (f19 ?v_0 ?v0) f1) (= (f19 ?v_0 ?v1) f1)))))) +(assert (forall ((?v0 S24) (?v1 S8) (?v2 S8)) (=> (= (f11 (f234 ?v0) (f12 (f13 f14 ?v1) ?v2)) f1) (= (f24 (f28 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 S3)) (=> (= (f15 (f235 ?v0) (f16 (f17 f18 ?v1) ?v2)) f1) (= (f19 (f31 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (=> (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1) (= (f34 (f35 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (=> (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (=> (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (= (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1) (= (f34 (f35 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (= (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (= (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (= (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (= (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S8)) (=> (= (f24 (f238 f185 ?v0) ?v1) f1) (=> (forall ((?v2 S17) (?v3 S17)) (=> (= ?v1 (f25 (f26 f27 ?v2) ?v3)) (=> (= (f20 (f42 ?v0 ?v2) ?v3) f1) false))) false)))) +(assert (forall ((?v0 S29) (?v1 S17)) (=> (= (f20 (f237 f187 ?v0) ?v1) f1) (=> (forall ((?v2 S18) (?v3 S18)) (=> (= ?v1 (f21 (f22 f23 ?v2) ?v3)) (=> (= (f38 (f39 ?v0 ?v2) ?v3) f1) false))) false)))) +(assert (forall ((?v0 S27) (?v1 S3)) (=> (= (f19 (f236 f189 ?v0) ?v1) f1) (=> (forall ((?v2 Int) (?v3 Int)) (=> (= ?v1 (f8 (f9 f10 ?v2) ?v3)) (=> (= (f34 (f35 ?v0 ?v2) ?v3) f1) false))) false)))) +(assert (forall ((?v0 S8) (?v1 S30)) (=> (forall ((?v2 S17) (?v3 S17)) (=> (= ?v0 (f25 (f26 f27 ?v2) ?v3)) (= (f20 (f42 ?v1 ?v2) ?v3) f1))) (= (f24 (f238 f185 ?v1) ?v0) f1)))) +(assert (forall ((?v0 S17) (?v1 S29)) (=> (forall ((?v2 S18) (?v3 S18)) (=> (= ?v0 (f21 (f22 f23 ?v2) ?v3)) (= (f38 (f39 ?v1 ?v2) ?v3) f1))) (= (f20 (f237 f187 ?v1) ?v0) f1)))) +(assert (forall ((?v0 S3) (?v1 S27)) (=> (forall ((?v2 Int) (?v3 Int)) (=> (= ?v0 (f8 (f9 f10 ?v2) ?v3)) (= (f34 (f35 ?v1 ?v2) ?v3) f1))) (= (f19 (f236 f189 ?v1) ?v0) f1)))) +(assert (forall ((?v0 S18) (?v1 S18)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) f303) f1) (< (f154 f155 ?v0) (f154 f155 ?v1))))) +(assert (= f304 (f103 (f104 f303) f303))) +(assert (= (f305 f303) f1)) +(assert (forall ((?v0 S103)) (= (f306 (f163 ?v0)) f1))) +(assert (forall ((?v0 S102)) (= (f307 (f161 ?v0)) f1))) +(assert (forall ((?v0 S21)) (= (= (f308 ?v0) f1) (forall ((?v1 S17) (?v2 S17)) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2))))))) +(assert (forall ((?v0 S16)) (= (= (f309 ?v0) f1) (forall ((?v1 S18) (?v2 S18)) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2))))))) +(assert (forall ((?v0 S15)) (= (= (f310 ?v0) f1) (forall ((?v1 Int) (?v2 Int)) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2))))))) +(assert (= (f307 f303) f1)) +(assert (forall ((?v0 S16) (?v1 S16)) (=> (= (f307 ?v0) f1) (=> (= (f307 ?v1) f1) (= (f306 (f103 (f104 ?v0) ?v1)) f1))))) +(assert (forall ((?v0 S16) (?v1 S16)) (=> (= (f305 ?v0) f1) (=> (= (f305 ?v1) f1) (= (f311 (f103 (f104 ?v0) ?v1)) f1))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (<= (f154 f155 ?v0) (f154 f155 ?v1)) (=> (< (f154 f155 ?v2) (f154 f155 ?v3)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f304) f1))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (< (f154 f155 ?v0) (f154 f155 ?v1)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f304) f1)))) +(assert (= (f306 f304) f1)) +(assert (forall ((?v0 S21) (?v1 S17)) (=> (= (f306 ?v0) f1) (=> (=> (not (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1)) false) false)))) +(assert (forall ((?v0 S16) (?v1 S18)) (=> (= (f307 ?v0) f1) (=> (=> (not (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1)) false) false)))) +(assert (forall ((?v0 S15) (?v1 Int)) (=> (= (f312 ?v0) f1) (=> (=> (not (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1)) false) false)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (=> (not (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1)) false) false))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (=> (not (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1)) false) false))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (=> (not (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1)) false) false))))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (not (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (not (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (not (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S21) (?v1 S17)) (=> (= (f306 ?v0) f1) (not (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S16) (?v1 S18)) (=> (= (f307 ?v0) f1) (not (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S15) (?v1 Int)) (=> (= (f312 ?v0) f1) (not (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S8) (?v1 S21)) (= (= (f44 ?v0 ?v1) f1) (= (f24 ?v1 ?v0) f1)))) +(assert (forall ((?v0 S17) (?v1 S16)) (= (= (f41 ?v0 ?v1) f1) (= (f20 ?v1 ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17) (?v3 S17)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f311 ?v0) f1) (=> (= (f44 (f25 ?v_0 ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v0) f1) (= (f44 (f25 ?v_0 ?v3) ?v0) f1))))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18) (?v3 S18)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f305 ?v0) f1) (=> (= (f41 (f21 ?v_0 ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v0) f1) (= (f41 (f21 ?v_0 ?v3) ?v0) f1))))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int) (?v3 Int)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f313 ?v0) f1) (=> (= (f37 (f8 ?v_0 ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v0) f1) (= (f37 (f8 ?v_0 ?v3) ?v0) f1))))))) +(assert (forall ((?v0 S21)) (= (= (f311 ?v0) f1) (forall ((?v1 S17) (?v2 S17) (?v3 S17)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f44 (f25 ?v_0 ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v0) f1) (= (f44 (f25 ?v_0 ?v3) ?v0) f1)))))))) +(assert (forall ((?v0 S16)) (= (= (f305 ?v0) f1) (forall ((?v1 S18) (?v2 S18) (?v3 S18)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f41 (f21 ?v_0 ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v0) f1) (= (f41 (f21 ?v_0 ?v3) ?v0) f1)))))))) +(assert (forall ((?v0 S15)) (= (= (f313 ?v0) f1) (forall ((?v1 Int) (?v2 Int) (?v3 Int)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f37 (f8 ?v_0 ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v0) f1) (= (f37 (f8 ?v_0 ?v3) ?v0) f1)))))))) +(assert (forall ((?v0 S21) (?v1 S103)) (=> (= (f306 ?v0) f1) (= (f306 (f173 (f174 ?v1) ?v0)) f1)))) +(assert (forall ((?v0 S16) (?v1 S102)) (=> (= (f307 ?v0) f1) (= (f307 (f171 (f172 ?v1) ?v0)) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f308 ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f309 ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f310 ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))))) +(assert (forall ((?v0 S28) (?v1 S43)) (=> (forall ((?v2 S18)) (=> (= (f38 ?v0 ?v2) f1) (= (f307 (f61 ?v1 ?v2)) f1))) (= (f306 (f62 (f63 ?v0) ?v1)) f1)))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S17) (?v2 S17)) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))) (= (f308 ?v0) f1)))) +(assert (forall ((?v0 S16)) (=> (forall ((?v1 S18) (?v2 S18)) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))) (= (f309 ?v0) f1)))) +(assert (forall ((?v0 S15)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))) (= (f310 ?v0) f1)))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S17) (?v2 S17) (?v3 S17)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f44 (f25 ?v_0 ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v0) f1) (= (f44 (f25 ?v_0 ?v3) ?v0) f1))))) (= (f311 ?v0) f1)))) +(assert (forall ((?v0 S16)) (=> (forall ((?v1 S18) (?v2 S18) (?v3 S18)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f41 (f21 ?v_0 ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v0) f1) (= (f41 (f21 ?v_0 ?v3) ?v0) f1))))) (= (f305 ?v0) f1)))) +(assert (forall ((?v0 S15)) (=> (forall ((?v1 Int) (?v2 Int) (?v3 Int)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f37 (f8 ?v_0 ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v0) f1) (= (f37 (f8 ?v_0 ?v3) ?v0) f1))))) (= (f313 ?v0) f1)))) +(assert (forall ((?v0 S21)) (= (= (f306 ?v0) f1) (forall ((?v1 S16) (?v2 S17)) (=> (= (f41 ?v2 ?v1) f1) (exists ((?v3 S17)) (and (= (f41 ?v3 ?v1) f1) (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (not (= (f41 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S16)) (= (= (f307 ?v0) f1) (forall ((?v1 S28) (?v2 S18)) (=> (= (f182 ?v2 ?v1) f1) (exists ((?v3 S18)) (and (= (f182 ?v3 ?v1) f1) (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (not (= (f182 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S6)) (= (= (f314 ?v0) f1) (forall ((?v1 S21) (?v2 S8)) (=> (= (f44 ?v2 ?v1) f1) (exists ((?v3 S8)) (and (= (f44 ?v3 ?v1) f1) (forall ((?v4 S8)) (=> (= (f30 (f12 (f13 f14 ?v4) ?v3) ?v0) f1) (not (= (f44 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S15)) (= (= (f312 ?v0) f1) (forall ((?v1 S26) (?v2 Int)) (=> (= (f179 ?v2 ?v1) f1) (exists ((?v3 Int)) (and (= (f179 ?v3 ?v1) f1) (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (not (= (f179 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S21) (?v1 S103) (?v2 S103)) (=> (forall ((?v3 S17) (?v4 S17)) (let ((?v_0 (f154 f155 (f164 ?v1 ?v3))) (?v_1 (f154 f155 (f164 ?v2 ?v4)))) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (and (<= (f154 f155 (f164 ?v1 ?v4)) ?v_0) (and (<= ?v_1 ?v_0) (< (f154 f155 (f164 ?v2 ?v3)) ?v_1)))))) (= (f306 ?v0) f1)))) +(assert (forall ((?v0 S16) (?v1 S102) (?v2 S102)) (=> (forall ((?v3 S18) (?v4 S18)) (let ((?v_0 (f154 f155 (f162 ?v1 ?v3))) (?v_1 (f154 f155 (f162 ?v2 ?v4)))) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (and (<= (f154 f155 (f162 ?v1 ?v4)) ?v_0) (and (<= ?v_1 ?v_0) (< (f154 f155 (f162 ?v2 ?v3)) ?v_1)))))) (= (f307 ?v0) f1)))) +(assert (forall ((?v0 S15) (?v1 S101) (?v2 S101)) (=> (forall ((?v3 Int) (?v4 Int)) (let ((?v_0 (f154 f155 (f160 ?v1 ?v3))) (?v_1 (f154 f155 (f160 ?v2 ?v4)))) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (and (<= (f154 f155 (f160 ?v1 ?v4)) ?v_0) (and (<= ?v_1 ?v_0) (< (f154 f155 (f160 ?v2 ?v3)) ?v_1)))))) (= (f312 ?v0) f1)))) +(assert (forall ((?v0 S21)) (= (= (f306 ?v0) f1) (not (exists ((?v1 S19)) (forall ((?v2 S18)) (= (f44 (f25 (f26 f27 (f21 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f21 ?v1 ?v2)) ?v0) f1))))))) +(assert (forall ((?v0 S16)) (= (= (f307 ?v0) f1) (not (exists ((?v1 S102)) (forall ((?v2 S18)) (= (f41 (f21 (f22 f23 (f162 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f162 ?v1 ?v2)) ?v0) f1))))))) +(assert (forall ((?v0 S15)) (= (= (f312 ?v0) f1) (not (exists ((?v1 S99)) (forall ((?v2 S18)) (= (f37 (f8 (f9 f10 (f154 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f154 ?v1 ?v2)) ?v0) f1))))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f316 (f43 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f317 (f40 ?v0)) f1)))) +(assert (forall ((?v0 S21) (?v1 S19)) (=> (= (f306 ?v0) f1) (=> (forall ((?v2 S18)) (=> (not (= (f44 (f25 (f26 f27 (f21 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f21 ?v1 ?v2)) ?v0) f1)) false)) false)))) +(assert (forall ((?v0 S16) (?v1 S102)) (=> (= (f307 ?v0) f1) (=> (forall ((?v2 S18)) (=> (not (= (f41 (f21 (f22 f23 (f162 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f162 ?v1 ?v2)) ?v0) f1)) false)) false)))) +(assert (forall ((?v0 S15) (?v1 S99)) (=> (= (f312 ?v0) f1) (=> (forall ((?v2 S18)) (=> (not (= (f37 (f8 (f9 f10 (f154 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f154 ?v1 ?v2)) ?v0) f1)) false)) false)))) +(assert (forall ((?v0 S24)) (= (= (f318 ?v0) f1) (forall ((?v1 S21) (?v2 S8)) (=> (= (f44 ?v2 ?v1) f1) (exists ((?v3 S8)) (and (= (f44 ?v3 ?v1) f1) (forall ((?v4 S8)) (=> (= (f24 (f28 ?v0 ?v4) ?v3) f1) (not (= (f44 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S30)) (= (= (f316 ?v0) f1) (forall ((?v1 S16) (?v2 S17)) (=> (= (f41 ?v2 ?v1) f1) (exists ((?v3 S17)) (and (= (f41 ?v3 ?v1) f1) (forall ((?v4 S17)) (=> (= (f20 (f42 ?v0 ?v4) ?v3) f1) (not (= (f41 ?v4 ?v1) f1))))))))))) +(assert (= (f307 f319) f1)) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (< (f154 f155 ?v0) (f154 f155 ?v1)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f320) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (<= (f154 f155 ?v0) (f154 f155 ?v1)) (=> (<= (f154 f155 ?v2) (f154 f155 ?v3)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f320) f1))))) +(assert (forall ((?v0 S21)) (= (= (f306 ?v0) f1) (forall ((?v1 S16)) (=> (forall ((?v2 S17)) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v3) ?v2) ?v0) f1) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))) (forall ((?v2 S17)) (= (f20 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S16)) (= (= (f307 ?v0) f1) (forall ((?v1 S28)) (=> (forall ((?v2 S18)) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v3) ?v2) ?v0) f1) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))) (forall ((?v2 S18)) (= (f38 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S15)) (= (= (f312 ?v0) f1) (forall ((?v1 S26)) (=> (forall ((?v2 Int)) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v3) ?v2) ?v0) f1) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))) (forall ((?v2 Int)) (= (f34 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S17) (?v2 S16)) (=> (= (f41 ?v1 ?v2) f1) (exists ((?v3 S17)) (and (= (f41 ?v3 ?v2) f1) (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (not (= (f41 ?v4 ?v2) f1)))))))) (= (f306 ?v0) f1)))) +(assert (forall ((?v0 S16)) (=> (forall ((?v1 S18) (?v2 S28)) (=> (= (f182 ?v1 ?v2) f1) (exists ((?v3 S18)) (and (= (f182 ?v3 ?v2) f1) (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (not (= (f182 ?v4 ?v2) f1)))))))) (= (f307 ?v0) f1)))) +(assert (forall ((?v0 S6)) (=> (forall ((?v1 S8) (?v2 S21)) (=> (= (f44 ?v1 ?v2) f1) (exists ((?v3 S8)) (and (= (f44 ?v3 ?v2) f1) (forall ((?v4 S8)) (=> (= (f30 (f12 (f13 f14 ?v4) ?v3) ?v0) f1) (not (= (f44 ?v4 ?v2) f1)))))))) (= (f314 ?v0) f1)))) +(assert (forall ((?v0 S15)) (=> (forall ((?v1 Int) (?v2 S26)) (=> (= (f179 ?v1 ?v2) f1) (exists ((?v3 Int)) (and (= (f179 ?v3 ?v2) f1) (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (not (= (f179 ?v4 ?v2) f1)))))))) (= (f312 ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S16) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (forall ((?v3 S17)) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (= (f20 ?v1 ?v4) f1))) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S16) (?v1 S28) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (forall ((?v3 S18)) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (= (f38 ?v1 ?v4) f1))) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S15) (?v1 S26) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (forall ((?v3 Int)) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (= (f34 ?v1 ?v4) f1))) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S21) (?v1 S16) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (forall ((?v3 S17)) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (= (f20 ?v1 ?v4) f1))) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S16) (?v1 S28) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (forall ((?v3 S18)) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (= (f38 ?v1 ?v4) f1))) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S15) (?v1 S26) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (forall ((?v3 Int)) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (= (f34 ?v1 ?v4) f1))) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S16)) (=> (= (f306 ?v0) f1) (=> (= (f41 ?v1 ?v2) f1) (=> (forall ((?v3 S17)) (=> (= (f41 ?v3 ?v2) f1) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (not (= (f41 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S28)) (=> (= (f307 ?v0) f1) (=> (= (f182 ?v1 ?v2) f1) (=> (forall ((?v3 S18)) (=> (= (f182 ?v3 ?v2) f1) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (not (= (f182 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S21)) (=> (= (f314 ?v0) f1) (=> (= (f44 ?v1 ?v2) f1) (=> (forall ((?v3 S8)) (=> (= (f44 ?v3 ?v2) f1) (=> (forall ((?v4 S8)) (=> (= (f30 (f12 (f13 f14 ?v4) ?v3) ?v0) f1) (not (= (f44 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 S26)) (=> (= (f312 ?v0) f1) (=> (= (f179 ?v1 ?v2) f1) (=> (forall ((?v3 Int)) (=> (= (f179 ?v3 ?v2) f1) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (not (= (f179 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (forall ((?v1 S16)) (=> (forall ((?v2 S17)) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v3) ?v2) ?v0) f1) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))) (forall ((?v2 S17)) (= (f20 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (forall ((?v1 S28)) (=> (forall ((?v2 S18)) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v3) ?v2) ?v0) f1) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))) (forall ((?v2 S18)) (= (f38 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S15)) (=> (= (f312 ?v0) f1) (forall ((?v1 S26)) (=> (forall ((?v2 Int)) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v3) ?v2) ?v0) f1) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))) (forall ((?v2 Int)) (= (f34 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f321 (f322 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f323 (f324 ?v0)) f1)))) +(assert (= f303 (f325 f319))) +(assert (forall ((?v0 S18) (?v1 S18)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f325 f319)) f1) (< (f154 f155 ?v0) (f154 f155 ?v1))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f306 (f326 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f307 (f325 ?v0)) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21)) (let ((?v_0 (f25 (f26 f27 ?v0) ?v1))) (=> (= (f44 ?v_0 ?v2) f1) (= (f44 ?v_0 (f326 ?v2)) f1))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16)) (let ((?v_0 (f21 (f22 f23 ?v0) ?v1))) (=> (= (f41 ?v_0 ?v2) f1) (= (f41 ?v_0 (f325 ?v2)) f1))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15)) (let ((?v_0 (f8 (f9 f10 ?v0) ?v1))) (=> (= (f37 ?v_0 ?v2) f1) (= (f37 ?v_0 (f327 ?v2)) f1))))) +(assert (forall ((?v0 S16)) (=> (= (f305 ?v0) f1) (= (f325 ?v0) ?v0)))) +(assert (forall ((?v0 S16)) (= (f305 (f325 ?v0)) f1))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_0 (f26 f27 ?v0))) (=> (= (f44 (f25 ?v_0 ?v1) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v2) f1) (= (f44 (f25 ?v_0 ?v3) (f326 ?v2)) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_0 (f22 f23 ?v0))) (=> (= (f41 (f21 ?v_0 ?v1) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v2) f1) (= (f41 (f21 ?v_0 ?v3) (f325 ?v2)) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_0 (f9 f10 ?v0))) (=> (= (f37 (f8 ?v_0 ?v1) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v2) f1) (= (f37 (f8 ?v_0 ?v3) (f327 ?v2)) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_0 (f26 f27 ?v0)) (?v_1 (f326 ?v2))) (=> (= (f44 (f25 ?v_0 ?v1) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v_1) f1) (= (f44 (f25 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_0 (f22 f23 ?v0)) (?v_1 (f325 ?v2))) (=> (= (f41 (f21 ?v_0 ?v1) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v_1) f1) (= (f41 (f21 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_0 (f9 f10 ?v0)) (?v_1 (f327 ?v2))) (=> (= (f37 (f8 ?v_0 ?v1) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v_1) f1) (= (f37 (f8 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S8) (?v1 S21)) (=> (= (f44 ?v0 ?v1) f1) (= (f44 ?v0 (f326 ?v1)) f1)))) +(assert (forall ((?v0 S17) (?v1 S16)) (=> (= (f41 ?v0 ?v1) f1) (= (f41 ?v0 (f325 ?v1)) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_1 (f26 f27 ?v0)) (?v_0 (f326 ?v2))) (=> (= (f44 (f25 ?v_1 ?v1) ?v_0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v_0) f1) (= (f44 (f25 ?v_1 ?v3) ?v_0) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_1 (f22 f23 ?v0)) (?v_0 (f325 ?v2))) (=> (= (f41 (f21 ?v_1 ?v1) ?v_0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v_0) f1) (= (f41 (f21 ?v_1 ?v3) ?v_0) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_1 (f9 f10 ?v0)) (?v_0 (f327 ?v2))) (=> (= (f37 (f8 ?v_1 ?v1) ?v_0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v_0) f1) (= (f37 (f8 ?v_1 ?v3) ?v_0) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_0 (f26 f27 ?v0)) (?v_1 (f326 ?v2))) (=> (= (f44 (f25 ?v_0 ?v1) ?v_1) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v2) f1) (= (f44 (f25 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_0 (f22 f23 ?v0)) (?v_1 (f325 ?v2))) (=> (= (f41 (f21 ?v_0 ?v1) ?v_1) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v2) f1) (= (f41 (f21 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_0 (f9 f10 ?v0)) (?v_1 (f327 ?v2))) (=> (= (f37 (f8 ?v_0 ?v1) ?v_1) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v2) f1) (= (f37 (f8 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21)) (let ((?v_0 (f25 (f26 f27 ?v0) ?v1))) (=> (= (f44 ?v_0 (f326 ?v2)) f1) (=> (=> (= (f44 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v3) (f326 ?v2)) f1) (=> (= (f44 (f25 (f26 f27 ?v3) ?v1) ?v2) f1) false))) false)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16)) (let ((?v_0 (f21 (f22 f23 ?v0) ?v1))) (=> (= (f41 ?v_0 (f325 ?v2)) f1) (=> (=> (= (f41 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v3) (f325 ?v2)) f1) (=> (= (f41 (f21 (f22 f23 ?v3) ?v1) ?v2) f1) false))) false)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15)) (let ((?v_0 (f8 (f9 f10 ?v0) ?v1))) (=> (= (f37 ?v_0 (f327 ?v2)) f1) (=> (=> (= (f37 ?v_0 ?v2) f1) false) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v3) (f327 ?v2)) f1) (=> (= (f37 (f8 (f9 f10 ?v3) ?v1) ?v2) f1) false))) false)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21)) (let ((?v_0 (f25 (f26 f27 ?v0) ?v1))) (=> (= (f44 ?v_0 (f326 ?v2)) f1) (=> (=> (= (f44 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v3) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v3) ?v1) (f326 ?v2)) f1) false))) false)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16)) (let ((?v_0 (f21 (f22 f23 ?v0) ?v1))) (=> (= (f41 ?v_0 (f325 ?v2)) f1) (=> (=> (= (f41 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v3) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v3) ?v1) (f325 ?v2)) f1) false))) false)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15)) (let ((?v_0 (f8 (f9 f10 ?v0) ?v1))) (=> (= (f37 ?v_0 (f327 ?v2)) f1) (=> (=> (= (f37 ?v_0 ?v2) f1) false) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v3) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v3) ?v1) (f327 ?v2)) f1) false))) false)))))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (forall ((?v3 S17)) (not (= (f44 (f25 (f26 f27 ?v3) ?v3) (f326 ?v0)) f1))) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (not (= ?v1 ?v2)))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (forall ((?v3 S18)) (not (= (f41 (f21 (f22 f23 ?v3) ?v3) (f325 ?v0)) f1))) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (not (= ?v1 ?v2)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (forall ((?v3 Int)) (not (= (f37 (f8 (f9 f10 ?v3) ?v3) (f327 ?v0)) f1))) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (not (= ?v1 ?v2)))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f321 (f328 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f323 (f329 ?v0)) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18) (?v4 S21) (?v5 S29)) (=> (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v1)) (f21 (f22 f23 ?v2) ?v3)) (f326 ?v4)) f1) (=> (forall ((?v6 S18) (?v7 S18)) (=> (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v1)) (f21 (f22 f23 ?v6) ?v7)) ?v4) f1) (= (f38 (f39 ?v5 ?v6) ?v7) f1))) (=> (forall ((?v6 S18) (?v7 S18) (?v8 S18) (?v9 S18)) (let ((?v_0 (f21 (f22 f23 ?v6) ?v7))) (=> (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v1)) ?v_0) (f326 ?v4)) f1) (=> (= (f44 (f25 (f26 f27 ?v_0) (f21 (f22 f23 ?v8) ?v9)) ?v4) f1) (=> (= (f38 (f39 ?v5 ?v6) ?v7) f1) (= (f38 (f39 ?v5 ?v8) ?v9) f1)))))) (= (f38 (f39 ?v5 ?v2) ?v3) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17) (?v4 S6) (?v5 S30)) (=> (= (f30 (f12 (f13 f14 (f25 (f26 f27 ?v0) ?v1)) (f25 (f26 f27 ?v2) ?v3)) (f330 ?v4)) f1) (=> (forall ((?v6 S17) (?v7 S17)) (=> (= (f30 (f12 (f13 f14 (f25 (f26 f27 ?v0) ?v1)) (f25 (f26 f27 ?v6) ?v7)) ?v4) f1) (= (f20 (f42 ?v5 ?v6) ?v7) f1))) (=> (forall ((?v6 S17) (?v7 S17) (?v8 S17) (?v9 S17)) (let ((?v_0 (f25 (f26 f27 ?v6) ?v7))) (=> (= (f30 (f12 (f13 f14 (f25 (f26 f27 ?v0) ?v1)) ?v_0) (f330 ?v4)) f1) (=> (= (f30 (f12 (f13 f14 ?v_0) (f25 (f26 f27 ?v8) ?v9)) ?v4) f1) (=> (= (f20 (f42 ?v5 ?v6) ?v7) f1) (= (f20 (f42 ?v5 ?v8) ?v9) f1)))))) (= (f20 (f42 ?v5 ?v2) ?v3) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S11) (?v5 S27)) (=> (= (f33 (f16 (f17 f18 (f8 (f9 f10 ?v0) ?v1)) (f8 (f9 f10 ?v2) ?v3)) (f331 ?v4)) f1) (=> (forall ((?v6 Int) (?v7 Int)) (=> (= (f33 (f16 (f17 f18 (f8 (f9 f10 ?v0) ?v1)) (f8 (f9 f10 ?v6) ?v7)) ?v4) f1) (= (f34 (f35 ?v5 ?v6) ?v7) f1))) (=> (forall ((?v6 Int) (?v7 Int) (?v8 Int) (?v9 Int)) (let ((?v_0 (f8 (f9 f10 ?v6) ?v7))) (=> (= (f33 (f16 (f17 f18 (f8 (f9 f10 ?v0) ?v1)) ?v_0) (f331 ?v4)) f1) (=> (= (f33 (f16 (f17 f18 ?v_0) (f8 (f9 f10 ?v8) ?v9)) ?v4) f1) (=> (= (f34 (f35 ?v5 ?v6) ?v7) f1) (= (f34 (f35 ?v5 ?v8) ?v9) f1)))))) (= (f34 (f35 ?v5 ?v2) ?v3) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S16)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v1) (f326 ?v2)) f1) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v1) ?v2) f1) (= (f20 ?v3 ?v4) f1))) (=> (forall ((?v4 S17) (?v5 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v5) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v5) ?v1) (f326 ?v2)) f1) (=> (= (f20 ?v3 ?v5) f1) (= (f20 ?v3 ?v4) f1))))) (= (f20 ?v3 ?v0) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S28)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v1) (f325 ?v2)) f1) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v1) ?v2) f1) (= (f38 ?v3 ?v4) f1))) (=> (forall ((?v4 S18) (?v5 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v5) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v5) ?v1) (f325 ?v2)) f1) (=> (= (f38 ?v3 ?v5) f1) (= (f38 ?v3 ?v4) f1))))) (= (f38 ?v3 ?v0) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 S26)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v1) (f327 ?v2)) f1) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v1) ?v2) f1) (= (f34 ?v3 ?v4) f1))) (=> (forall ((?v4 Int) (?v5 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v5) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v5) ?v1) (f327 ?v2)) f1) (=> (= (f34 ?v3 ?v5) f1) (= (f34 ?v3 ?v4) f1))))) (= (f34 ?v3 ?v0) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S16)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v1) (f326 ?v2)) f1) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v4) ?v2) f1) (= (f20 ?v3 ?v4) f1))) (=> (forall ((?v4 S17) (?v5 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v4) (f326 ?v2)) f1) (=> (= (f44 (f25 (f26 f27 ?v4) ?v5) ?v2) f1) (=> (= (f20 ?v3 ?v4) f1) (= (f20 ?v3 ?v5) f1))))) (= (f20 ?v3 ?v1) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S28)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v1) (f325 ?v2)) f1) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v4) ?v2) f1) (= (f38 ?v3 ?v4) f1))) (=> (forall ((?v4 S18) (?v5 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v4) (f325 ?v2)) f1) (=> (= (f41 (f21 (f22 f23 ?v4) ?v5) ?v2) f1) (=> (= (f38 ?v3 ?v4) f1) (= (f38 ?v3 ?v5) f1))))) (= (f38 ?v3 ?v1) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 S26)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v1) (f327 ?v2)) f1) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v4) ?v2) f1) (= (f34 ?v3 ?v4) f1))) (=> (forall ((?v4 Int) (?v5 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v4) (f327 ?v2)) f1) (=> (= (f37 (f8 (f9 f10 ?v4) ?v5) ?v2) f1) (=> (= (f34 ?v3 ?v4) f1) (= (f34 ?v3 ?v5) f1))))) (= (f34 ?v3 ?v1) f1)))))) +(assert (forall ((?v0 S18)) (= (f160 f315 (f154 f155 ?v0)) ?v0))) +(assert (forall ((?v0 Int)) (=> (<= 0 ?v0) (= (f154 f155 (f160 f315 ?v0)) ?v0)))) +(assert (forall ((?v0 Int)) (=> (< ?v0 0) (= (f154 f155 (f160 f315 ?v0)) 0)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/red-exp.smt2 b/test/regress/regress1/nl/red-exp.smt2 new file mode 100644 index 000000000..5dc5258e2 --- /dev/null +++ b/test/regress/regress1/nl/red-exp.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) + +(assert (or (= a (* b b)) (and (= a 9) (= b 3)))) +(assert (not (= (* a a) (* b b b b)))) +(check-sat) diff --git a/test/regress/regress1/nl/rewriting-sums.smt2 b/test/regress/regress1/nl/rewriting-sums.smt2 new file mode 100644 index 000000000..ca2edf024 --- /dev/null +++ b/test/regress/regress1/nl/rewriting-sums.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NIA) +(set-info :status unsat) +(declare-fun x () Int) +(declare-fun y () Int) +(declare-fun z () Int) + + +(assert (or (= x 5) (= x 7) (= x 9))) + +(assert (or (= y (+ x 1)) (= y (+ x 2)))) + +(assert (or (= z (+ y 5)) (= z (+ y 10)))) + +(assert (> (* z z) 1000000000)) + +(check-sat) diff --git a/test/regress/regress1/nl/shifting.smt2 b/test/regress/regress1/nl/shifting.smt2 new file mode 100644 index 000000000..320c92d58 --- /dev/null +++ b/test/regress/regress1/nl/shifting.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --nl-ext --nl-ext-tplanes +; EXPECT: sat +(set-logic QF_NIRA) +(set-info :status sat) +(declare-fun pi () Real) + +(assert (and (< 3.0 pi) (< pi 3.5))) + +(declare-fun y () Real) +(assert (and (<= (- pi) y) (<= y pi))) + +(declare-fun s () Int) + +(declare-fun z () Real) + +(assert (= z (* 2 pi s))) + +(assert (> z 60)) + +(check-sat) diff --git a/test/regress/regress1/nl/shifting2.smt2 b/test/regress/regress1/nl/shifting2.smt2 new file mode 100644 index 000000000..c5e805c50 --- /dev/null +++ b/test/regress/regress1/nl/shifting2.smt2 @@ -0,0 +1,22 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NIRA) +(set-info :status unsat) +(declare-fun pi () Real) + +(assert (and (< 3.0 pi) (< pi 3.5))) + +(declare-fun y () Real) +(assert (and (< (- pi) y) (< y pi))) + +(declare-fun s () Int) + +(declare-fun z () Real) + +(assert (= z (+ y (* 2 pi s)))) + +(assert (and (< (- pi) z) (< z pi))) + +(assert (not (= z y))) + +(check-sat) diff --git a/test/regress/regress1/nl/siegel-nl-bases.smt2 b/test/regress/regress1/nl/siegel-nl-bases.smt2 deleted file mode 100644 index cf6e3ab5e..000000000 --- a/test/regress/regress1/nl/siegel-nl-bases.smt2 +++ /dev/null @@ -1,22 +0,0 @@ -; COMMAND-LINE: --nl-ext -; EXPECT: unsat -(set-logic QF_NIA) -(declare-const n Int) -(declare-const i1 Int) -(declare-const i2 Int) -(declare-const j1 Int) -(declare-const j2 Int) -(assert (>= n 0)) -(assert (not (= i1 i2))) -(assert (<= 0 i1)) -(assert (<= i1 j1)) -(assert (< j1 n)) -(assert (<= 0 i2)) -(assert (<= i2 j2)) -(assert (< j2 n)) -(assert (or - (= (+ (* i1 n) j1) (+ (* i2 n) j2)) - (= (+ (* i1 n) j1) (+ (* j2 n) i2)) - (= (+ (* j1 n) i1) (+ (* i2 n) j2)) - (= (+ (* j1 n) i1) (+ (* j2 n) i2)))) -(check-sat) diff --git a/test/regress/regress1/nl/simple-mono-unsat.smt2 b/test/regress/regress1/nl/simple-mono-unsat.smt2 new file mode 100644 index 000000000..b82b7ad7c --- /dev/null +++ b/test/regress/regress1/nl/simple-mono-unsat.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(declare-fun d () Real) + +(assert (or (= a 4) (= a 3))) + +(assert (> b 0)) +(assert (> c 0)) + +(assert (< (* a b c d d) 0)) + +(check-sat) diff --git a/test/regress/regress1/nl/simple-mono.smt2 b/test/regress/regress1/nl/simple-mono.smt2 new file mode 100644 index 000000000..3d4adad28 --- /dev/null +++ b/test/regress/regress1/nl/simple-mono.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) +(declare-fun y () Real) +(declare-fun z () Real) + + +(assert (> z 0)) +(assert (> x y)) + +;(assert (not (> (* x z) (* y z)))) +(assert (< (* x z) (* y z))) + + +(check-sat) diff --git a/test/regress/regress1/nl/sin-compare-across-phase.smt2 b/test/regress/regress1/nl/sin-compare-across-phase.smt2 new file mode 100644 index 000000000..f5d7fe32d --- /dev/null +++ b/test/regress/regress1/nl/sin-compare-across-phase.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --nl-ext --nl-ext-tplanes +; EXPECT: unsat +(set-logic QF_UFNRA) +(set-info :status unsat) +(declare-fun x () Real) +(assert (< (sin 3.1) (sin 3.3))) +(check-sat) diff --git a/test/regress/regress1/nl/sin-compare.smt2 b/test/regress/regress1/nl/sin-compare.smt2 new file mode 100644 index 000000000..790d7037f --- /dev/null +++ b/test/regress/regress1/nl/sin-compare.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --nl-ext --nl-ext-tplanes +; EXPECT: unsat +(set-logic QF_UFNRA) +(set-info :status unsat) +(declare-fun x () Real) +(assert (or (> (sin 0.1) (sin 0.2)) (> (sin 6.4) (sin 6.5)))) +(check-sat) diff --git a/test/regress/regress1/nl/sin-init-tangents.smt2 b/test/regress/regress1/nl/sin-init-tangents.smt2 new file mode 100644 index 000000000..e71ab231f --- /dev/null +++ b/test/regress/regress1/nl/sin-init-tangents.smt2 @@ -0,0 +1,6 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(assert (or (> (sin 0.8) 0.9) (< (sin (- 0.7)) (- 0.75)) (= (sin 3.0) 0.8))) +(check-sat) diff --git a/test/regress/regress1/nl/sin-sign.smt2 b/test/regress/regress1/nl/sin-sign.smt2 new file mode 100644 index 000000000..9b05a3d52 --- /dev/null +++ b/test/regress/regress1/nl/sin-sign.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --nl-ext --nl-ext-tplanes +; EXPECT: unsat +(set-logic QF_UFNRA) +(set-info :status unsat) +(declare-fun x () Real) +(assert (or (< (sin 0.2) (- 0.1)) (> (sin (- 0.05)) 0.05))) +(check-sat) diff --git a/test/regress/regress1/nl/sin-sym2.smt2 b/test/regress/regress1/nl/sin-sym2.smt2 new file mode 100644 index 000000000..2e5d4eac2 --- /dev/null +++ b/test/regress/regress1/nl/sin-sym2.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --nl-ext --nl-ext-tplanes +; EXPECT: unsat +(set-logic QF_UFNRA) +(set-info :status unsat) +(declare-fun x () Real) +(declare-fun y () Real) +(assert (and (< 0.0 x) (< x 1.0) (< 0.0 y) (< y 1.0))) +(assert (= (+ (sin x) (sin y)) 0.0)) +(assert (not (= (+ x y) 0.0))) +(check-sat) diff --git a/test/regress/regress1/nl/sin1-lb.smt2 b/test/regress/regress1/nl/sin1-lb.smt2 new file mode 100644 index 000000000..f8070cdb8 --- /dev/null +++ b/test/regress/regress1/nl/sin1-lb.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) + +(assert (> (sin 1) 0.842)) +(assert (= x (sin 1))) + +(check-sat) diff --git a/test/regress/regress1/nl/sin1-sat.smt2 b/test/regress/regress1/nl/sin1-sat.smt2 new file mode 100644 index 000000000..d6275c6e8 --- /dev/null +++ b/test/regress/regress1/nl/sin1-sat.smt2 @@ -0,0 +1,12 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes --no-check-models +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) + +(assert (> (sin 1) 0.84)) +(assert (< (sin 1) 0.85)) +(assert (< (- x (sin 1)) 0.000001)) +(assert (< (- (sin 1) x) 0.000001)) + +(check-sat) diff --git a/test/regress/regress1/nl/sin1-ub.smt2 b/test/regress/regress1/nl/sin1-ub.smt2 new file mode 100644 index 000000000..47d322a77 --- /dev/null +++ b/test/regress/regress1/nl/sin1-ub.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) + +(assert (< (sin 1) 0.8414)) +(assert (= x (sin 1))) + +(check-sat) diff --git a/test/regress/regress1/nl/sin2-lb.smt2 b/test/regress/regress1/nl/sin2-lb.smt2 new file mode 100644 index 000000000..686708230 --- /dev/null +++ b/test/regress/regress1/nl/sin2-lb.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) + +(assert (> (sin 2) 0.96)) +(assert (= x (sin 2))) + +(check-sat) diff --git a/test/regress/regress1/nl/sin2-ub.smt2 b/test/regress/regress1/nl/sin2-ub.smt2 new file mode 100644 index 000000000..51c9eb8a9 --- /dev/null +++ b/test/regress/regress1/nl/sin2-ub.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) + +(assert (< (sin 2) 0.901)) +(assert (= x (sin 2))) + +(check-sat) diff --git a/test/regress/regress1/nl/sqrt-problem-1.smt2 b/test/regress/regress1/nl/sqrt-problem-1.smt2 new file mode 100644 index 000000000..e74af3a2d --- /dev/null +++ b/test/regress/regress1/nl/sqrt-problem-1.smt2 @@ -0,0 +1,41 @@ +; COMMAND-LINE: --nl-ext-tplanes +; EXPECT: unsat +(set-logic ALL) +(set-info :status unsat) +(declare-fun X () Real) +(declare-fun |sqrt{10}| () Real) +(declare-fun |sqrt{8}| () Real) +(assert (let ((.def_48 (<= X (to_real 300)))) +(let ((.def_47 (<= (to_real (- 300)) X))) +(let ((.def_49 (and .def_47 .def_48))) +(let ((.def_44 (<= |sqrt{10}| (to_real 300)))) +(let ((.def_43 (<= (to_real (- 300)) |sqrt{10}|))) +(let ((.def_45 (and .def_43 .def_44))) +(let ((.def_40 (<= |sqrt{8}| (to_real 300)))) +(let ((.def_39 (<= (to_real (- 300)) |sqrt{8}|))) +(let ((.def_41 (and .def_39 .def_40))) +(let ((.def_35 (<= (to_real 0) |sqrt{8}|))) +(let ((.def_31 (* |sqrt{8}| |sqrt{8}|))) +(let ((.def_33 (= .def_31 (to_real 3)))) +(let ((.def_29 (<= (to_real 0) |sqrt{10}|))) +(let ((.def_26 (* |sqrt{10}| |sqrt{10}|))) +(let ((.def_27 (= X .def_26))) +(let ((.def_21 (<= X (to_real 2)))) +(let ((.def_19 (<= (to_real 0) X))) +(let ((.def_22 (and .def_19 .def_21))) +(let ((.def_23 (not .def_22))) +(let ((.def_11 (+ |sqrt{10}| |sqrt{8}|))) +(let ((.def_15 (<= (/ 63 20) .def_11))) +(let ((.def_16 (not .def_15))) +(let ((.def_24 (or .def_16 .def_23))) +(let ((.def_25 (not .def_24))) +(let ((.def_28 (and .def_25 .def_27))) +(let ((.def_30 (and .def_28 .def_29))) +(let ((.def_34 (and .def_30 .def_33))) +(let ((.def_36 (and .def_34 .def_35))) +(let ((.def_42 (and .def_36 .def_41))) +(let ((.def_46 (and .def_42 .def_45))) +(let ((.def_50 (and .def_46 .def_49))) +.def_50)))))))))))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/nl/sugar-ident-2.smt2 b/test/regress/regress1/nl/sugar-ident-2.smt2 new file mode 100644 index 000000000..84c224715 --- /dev/null +++ b/test/regress/regress1/nl/sugar-ident-2.smt2 @@ -0,0 +1,27 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(declare-fun x5 () Real) + +(declare-fun a1 () Bool) +(declare-fun a2 () Bool) +(declare-fun a3 () Bool) +(declare-fun a4 () Bool) +(declare-fun a5 () Bool) +(declare-fun a6 () Bool) +(declare-fun a7 () Bool) + +(assert (= a2 (and (> (sin 1.0) 0.0) (> (cot 1.0) (/ (cos 1.0) (sin 1.0)))))) +(assert (= a7 (> (* (sec 1.0) (cos 1.0)) 1.0))) + +(assert (or +a2 +a7 +)) + +(check-sat) diff --git a/test/regress/regress1/nl/sugar-ident-3.smt2 b/test/regress/regress1/nl/sugar-ident-3.smt2 new file mode 100644 index 000000000..ab50bcb1d --- /dev/null +++ b/test/regress/regress1/nl/sugar-ident-3.smt2 @@ -0,0 +1,8 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun a6 () Bool) +(assert (= a6 (> (* (csc 1.0) (sin 1.0)) 1.0))) +(assert a6) +(check-sat) diff --git a/test/regress/regress1/nl/sugar-ident.smt2 b/test/regress/regress1/nl/sugar-ident.smt2 new file mode 100644 index 000000000..95dbbc5fc --- /dev/null +++ b/test/regress/regress1/nl/sugar-ident.smt2 @@ -0,0 +1,23 @@ +; COMMAND-LINE: --nl-ext-tf-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(declare-fun x5 () Real) + +(declare-fun a1 () Bool) +(declare-fun a3 () Bool) +(declare-fun a4 () Bool) +(declare-fun a5 () Bool) +(declare-fun a6 () Bool) + +(assert (= a1 (not (= (sin (arcsin x1)) x1)))) +(assert (= a3 (< (arccos x3) 0))) +(assert (= a4 (> (arctan x4) 1.8))) + +(assert (or a1 a3 a4)) + +(check-sat) diff --git a/test/regress/regress1/nl/tan-rewrite2.smt2 b/test/regress/regress1/nl/tan-rewrite2.smt2 new file mode 100644 index 000000000..af39f7559 --- /dev/null +++ b/test/regress/regress1/nl/tan-rewrite2.smt2 @@ -0,0 +1,13 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_UFNRA) +(set-info :status unsat) +(declare-fun x () Real) + + +(assert (= (tan x) (sin x))) +(assert (> (cos x) 0)) +(assert (not (= (cos x) 1))) +(assert (not (= (sin x) 0))) + +(check-sat) diff --git a/test/regress/regress1/nl/zero-subset.smt2 b/test/regress/regress1/nl/zero-subset.smt2 new file mode 100644 index 000000000..a8ce65b02 --- /dev/null +++ b/test/regress/regress1/nl/zero-subset.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --nl-ext +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(declare-fun d () Real) +(declare-fun e () Real) + +(assert (= (* a b c d) 0)) + +(assert (not (= (* a b c d e) 0))) + +(check-sat) diff --git a/test/regress/regress1/non-fatal-errors.smt2 b/test/regress/regress1/non-fatal-errors.smt2 new file mode 100644 index 000000000..1e1865883 --- /dev/null +++ b/test/regress/regress1/non-fatal-errors.smt2 @@ -0,0 +1,29 @@ +; SCRUBBER: sed 's/".*"/""/g' +; EXPECT: success +; EXPECT: success +; EXPECT: success +; EXPECT: success +; EXPECT: success +; EXPECT: success +; EXPECT: success +; EXPECT: (error "") +; EXPECT: (error "") +; EXPECT: (error "") +; EXPECT: (error "") +; EXPECT: (error "") +; EXPECT: success +; EXPECT: sat +(set-option :print-success true) +(set-option :produce-unsat-cores true) +(set-option :produce-models true) +(set-option :produce-proofs true) +(set-option :produce-assignments true) +(set-logic UF) +(declare-fun p () Bool) +(get-unsat-core) +(get-value (p)) +(get-proof) +(get-model) +(get-assignment) +(assert true) +(check-sat) diff --git a/test/regress/regress1/parsing_ringer.cvc b/test/regress/regress1/parsing_ringer.cvc new file mode 100644 index 000000000..2c2018ecd --- /dev/null +++ b/test/regress/regress1/parsing_ringer.cvc @@ -0,0 +1,94 @@ +% Test for presentiation language parsing, some edge cases with cascading +% store terms. Intended to put this part of the parser "through the ringer," +% hence the name. + +% COMMAND-LINE: --incremental +% EXPECT: sat +% EXPECT: sat +% EXPECT: sat +% EXPECT: sat +% EXPECT: sat +% EXPECT: sat +% EXPECT: sat +% EXPECT: sat +% EXPECT: unsat +% EXPECT: unsat +% EXPECT: sat + +PUSH; + +x, y : ARRAY INT OF ARRAY INT OF ARRAY INT OF INT; + +% multidimensional arrays +ASSERT x[0][0][0] = 0; %% select +ASSERT y = x WITH [0][0][1] := 1; %% partial store + +CHECKSAT; + +% mixed stores: records of arrays of tuples, oh my +z : [# x:ARRAY INT OF [# x:INT #], y:[ARRAY INT OF INT, ARRAY INT OF INT] #]; + +arr1 : ARRAY INT OF [# x:INT #]; +arr2 : [ ARRAY INT OF INT, ARRAY INT OF INT ]; + +ASSERT arr1[0].x = 0; +ASSERT arr2.0[0] = 1; +ASSERT arr2.1[0] = 5; + +ASSERT z.y.1[1] /= 1; +ASSERT (# x:=arr1, y:=arr2 #) = z; + +CHECKSAT; + +ASSERT z.x[0].x /= z.y.0[5]; + +CHECKSAT; + +ASSERT z.y.0[1] = z.x[5].x; + +CHECKSAT; + +ASSERT z.y.0[5] = z.x[-2].x; + +CHECKSAT; + +POP; + +a : ARRAY INT OF ARRAY INT OF INT; +b : ARRAY INT OF INT; + +% ambiguity in presentation language, comma needs to bind to innermost WITH +% causes type error if the [2]:=2 at the end is attached to the wrong WITH +ASSERT a = a WITH [0]:=b WITH [1]:=1,[2]:=2; + +CHECKSAT; + +RESET; + +% more mixed stores, this time with constant arrays +z : [# x:ARRAY INT OF [# x:INT #], y:[ARRAY INT OF INT, ARRAY INT OF INT] #]; + +ASSERT z.y.1[1] /= 1; +ASSERT (# x:=ARRAY(INT OF [# x:INT #]):(# x:=0 #), y:=(ARRAY(INT OF INT):1, ARRAY(INT OF INT):5) #) = z; + +CHECKSAT; + +ASSERT z.x[0].x /= z.y.0[5]; + +CHECKSAT; + +ASSERT z.y.0[1] = z.x[5].x; + +CHECKSAT; + +ASSERT z.y.0[5] = z.x[-2].x; + +CHECKSAT; + +RESET; + +a : ARRAY INT OF INT; + +ASSERT a = a WITH [0]:=0, [1]:=1; + +CHECKSAT; diff --git a/test/regress/regress1/proof00.smt2 b/test/regress/regress1/proof00.smt2 new file mode 100644 index 000000000..1b7e7b8dd --- /dev/null +++ b/test/regress/regress1/proof00.smt2 @@ -0,0 +1,21 @@ +; PROOF +(set-logic QF_UF) +(set-info :source | +CADE ATP System competition. See http://www.cs.miami.edu/~tptp/CASC + for more information. + +This benchmark was obtained by trying to find a finite model of a first-order +formula (Albert Oliveras). +|) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-sort U 0) +(declare-fun c3 () U) +(declare-fun f1 (U U) U) +(declare-fun f4 (U) U) +(declare-fun c2 () U) +(declare-fun c_0 () U) +(declare-fun c_1 () U) +(assert (let ((?v_1 (f1 c3 c_0))) (let ((?v_0 (f1 ?v_1 c_0)) (?v_2 (f1 c_0 c_0)) (?v_4 (f1 c_0 c_1)) (?v_3 (f1 ?v_1 c_1)) (?v_6 (f1 c3 c_1))) (let ((?v_5 (f1 ?v_6 c_0)) (?v_7 (f1 c_1 c_0)) (?v_9 (f1 c_1 c_1)) (?v_8 (f1 ?v_6 c_1)) (?v_10 (f4 c_0))) (let ((?v_11 (f1 c_0 ?v_10)) (?v_12 (f4 c_1))) (let ((?v_13 (f1 c_1 ?v_12)) (?v_15 (f1 c2 c_0))) (let ((?v_14 (f1 ?v_15 c_0)) (?v_16 (f1 ?v_15 c_1)) (?v_18 (f1 c2 c_1))) (let ((?v_17 (f1 ?v_18 c_0)) (?v_19 (f1 ?v_18 c_1))) (and (distinct c_0 c_1) (= (f1 ?v_0 c_0) (f1 c_0 ?v_2)) (= (f1 ?v_0 c_1) (f1 c_0 ?v_4)) (= (f1 ?v_3 c_0) (f1 c_1 ?v_2)) (= (f1 ?v_3 c_1) (f1 c_1 ?v_4)) (= (f1 ?v_5 c_0) (f1 c_0 ?v_7)) (= (f1 ?v_5 c_1) (f1 c_0 ?v_9)) (= (f1 ?v_8 c_0) (f1 c_1 ?v_7)) (= (f1 ?v_8 c_1) (f1 c_1 ?v_9)) (not (= ?v_11 (f1 ?v_10 ?v_11))) (not (= ?v_13 (f1 ?v_12 ?v_13))) (= (f1 ?v_14 c_0) (f1 (f1 ?v_2 c_0) c_0)) (= (f1 ?v_14 c_1) (f1 (f1 ?v_4 c_0) c_1)) (= (f1 ?v_16 c_0) (f1 (f1 ?v_2 c_1) c_0)) (= (f1 ?v_16 c_1) (f1 (f1 ?v_4 c_1) c_1)) (= (f1 ?v_17 c_0) (f1 (f1 ?v_7 c_0) c_0)) (= (f1 ?v_17 c_1) (f1 (f1 ?v_9 c_0) c_1)) (= (f1 ?v_19 c_0) (f1 (f1 ?v_7 c_1) c_0)) (= (f1 ?v_19 c_1) (f1 (f1 ?v_9 c_1) c_1)) (or (= ?v_2 c_0) (= ?v_2 c_1)) (or (= ?v_4 c_0) (= ?v_4 c_1)) (or (= ?v_7 c_0) (= ?v_7 c_1)) (or (= ?v_9 c_0) (= ?v_9 c_1)) (or (= ?v_10 c_0) (= ?v_10 c_1)) (or (= ?v_12 c_0) (= ?v_12 c_1)) (or (= c3 c_0) (= c3 c_1)) (or (= c2 c_0) (= c2 c_1))))))))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/Makefile.am b/test/regress/regress1/push-pop/Makefile.am new file mode 100644 index 000000000..d1fe52984 --- /dev/null +++ b/test/regress/regress1/push-pop/Makefile.am @@ -0,0 +1,92 @@ +# don't override a BINARY imported from a personal.mk +@mk_if@eq ($(BINARY),) +@mk_empty@BINARY = cvc4 +end@mk_if@ + +LOG_COMPILER = @srcdir@/../../run_regression +AM_LOG_FLAGS = $(RUN_REGRESSION_ARGS) @abs_top_builddir@/src/main/$(BINARY)$(EXEEXT) + +if AUTOMAKE_1_11 +# old-style (pre-automake 1.12) test harness +TESTS_ENVIRONMENT = \ + $(LOG_COMPILER) \ + $(AM_LOG_FLAGS) $(LOG_FLAGS) +endif + +# These are run for all build profiles. +# If a test shouldn't be run in e.g. competition mode, +# put it below in "TESTS +=" +TESTS = \ + arith_lra_01.smt2 \ + arith_lra_02.smt2 \ + bug-fmf-fun-skolem.smt2 \ + bug216.smt2 \ + bug326.smt2 \ + fuzz_1_to_52_merged.smt2 \ + fuzz_1.smt2 \ + fuzz_10.smt2 \ + fuzz_11.smt2 \ + fuzz_15.smt2 \ + fuzz_16.smt2 \ + fuzz_19.smt2 \ + fuzz_20.smt2 \ + fuzz_23.smt2 \ + fuzz_24.smt2 \ + fuzz_25.smt2 \ + fuzz_26.smt2 \ + fuzz_28.smt2 \ + fuzz_29.smt2 \ + fuzz_3_1.smt2 \ + fuzz_3_10.smt2 \ + fuzz_3_11.smt2 \ + fuzz_3_12.smt2 \ + fuzz_3_13.smt2 \ + fuzz_3_14.smt2 \ + fuzz_3_15.smt2 \ + fuzz_3_2.smt2 \ + fuzz_3_3.smt2 \ + fuzz_3_4.smt2 \ + fuzz_3_5.smt2 \ + fuzz_3_6.smt2 \ + fuzz_3_7.smt2 \ + fuzz_3_8.smt2 \ + fuzz_3_9.smt2 \ + fuzz_30.smt2 \ + fuzz_32.smt2 \ + fuzz_34.smt2 \ + fuzz_35.smt2 \ + fuzz_37.smt2 \ + fuzz_39.smt2 \ + fuzz_4.smt2 \ + fuzz_40.smt2 \ + fuzz_41.smt2 \ + fuzz_42.smt2 \ + fuzz_43.smt2 \ + fuzz_44.smt2 \ + fuzz_45.smt2 \ + fuzz_5_1.smt2 \ + fuzz_5_2.smt2 \ + fuzz_5_3.smt2 \ + fuzz_5_4.smt2 \ + fuzz_5_5.smt2 \ + fuzz_5_6.smt2 \ + fuzz_5.smt2 \ + fuzz_51.smt2 \ + fuzz_52.smt2 \ + fuzz_6.smt2 \ + fuzz_7.smt2 \ + fuzz_8.smt2 \ + fuzz_9.smt2 \ + quant-fun-proc-unmacro.smt2 \ + quant-fun-proc.smt2 + +EXTRA_DIST = $(TESTS) \ + bug216.smt2.expect + +# synonyms for "check" in this directory +.PHONY: regress regress1 test +regress regress1 test: check + +# do nothing in this subdir +.PHONY: regress0 regress2 regress3 regress4 +regress0 regress2 regress3 regress4: diff --git a/test/regress/regress1/push-pop/arith_lra_01.smt2 b/test/regress/regress1/push-pop/arith_lra_01.smt2 new file mode 100644 index 000000000..4216f429a --- /dev/null +++ b/test/regress/regress1/push-pop/arith_lra_01.smt2 @@ -0,0 +1,105 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(assert (or (not (>= (+ (* 17 x1 ) (* 46 x1 ) (* (- 8) x2 ) (* 12 x4 ) (* (- 39) x4 ) (* (- 21) x4 ) (* (- 24) x0 ) (* 31 x3 ) (* (- 31) x2 ) (* 37 x0 ) ) (- 8))) (>= (+ (* (- 2) x3 ) (* (- 22) x1 ) ) (- 42)) )) +(assert (or (not (> (+ (* 49 x0 ) (* 34 x2 ) (* 18 x4 ) ) 45)) (not (= (+ (* 39 x3 ) (* (- 50) x0 ) (* 18 x3 ) (* (- 48) x4 ) (* 26 x3 ) (* 36 x3 ) (* 32 x1 ) ) (- 36))) (> (+ (* (- 41) x3 ) (* (- 22) x1 ) (* 5 x4 ) (* 25 x4 ) (* (- 39) x0 ) (* (- 26) x2 ) (* (- 15) x1 ) (* (- 49) x3 ) ) (- 15)) )) +(assert (or (<= (+ (* (- 17) x2 ) (* (- 20) x3 ) (* (- 15) x0 ) (* (- 23) x2 ) (* 27 x3 ) (* 12 x2 ) (* 48 x2 ) (* (- 29) x2 ) ) (- 25)) (= (+ (* 0 x4 ) (* (- 15) x2 ) (* (- 11) x4 ) (* 23 x0 ) (* (- 10) x2 ) (* (- 30) x0 ) (* (- 26) x4 ) ) (- 48)) (not (< (+ (* (- 43) x2 ) (* (- 44) x3 ) (* (- 43) x4 ) (* (- 11) x4 ) (* (- 21) x0 ) (* 15 x1 ) (* (- 45) x3 ) (* 0 x2 ) (* 21 x2 ) (* (- 45) x1 ) (* 8 x0 ) ) (- 5))) )) +(check-sat) +(push 1) +(assert (not (< (+ (* (- 44) x0 ) (* 45 x3 ) (* 34 x2 ) (* 14 x1 ) (* (- 43) x0 ) (* 19 x0 ) (* 12 x3 ) (* (- 49) x2 ) ) (- 21))) ) +(check-sat) +(pop 1) +(assert (or (>= (+ (* 21 x0 ) (* (- 15) x3 ) (* 29 x2 ) (* 35 x3 ) (* 39 x4 ) (* 12 x2 ) ) 13) (not (= (+ (* (- 38) x2 ) (* (- 11) x2 ) ) 26)) (< (+ (* 41 x0 ) (* (- 27) x4 ) (* 20 x0 ) (* (- 29) x4 ) (* (- 30) x3 ) (* (- 30) x3 ) (* 21 x4 ) (* (- 15) x2 ) (* 0 x2 ) (* (- 23) x3 ) (* 43 x2 ) ) (- 18)) )) +(assert (or (not (< (+ (* (- 19) x3 ) (* 25 x2 ) (* (- 47) x2 ) (* 39 x4 ) (* (- 15) x3 ) (* 16 x2 ) ) 5)) (>= (+ (* 46 x1 ) (* 9 x2 ) (* 42 x1 ) (* 48 x3 ) (* 20 x0 ) ) 40) )) +(assert (or (not (= (+ (* (- 40) x2 ) (* 24 x3 ) (* 7 x0 ) (* 40 x1 ) (* 28 x4 ) (* 2 x3 ) (* (- 3) x3 ) (* (- 50) x3 ) (* (- 50) x3 ) (* (- 9) x1 ) (* (- 1) x2 ) ) 41)) (= (+ (* (- 1) x0 ) (* 9 x3 ) ) (- 19)) (not (>= (+ (* 37 x2 ) (* 0 x3 ) (* (- 7) x2 ) (* 36 x4 ) (* 32 x0 ) (* (- 45) x0 ) (* 30 x4 ) (* (- 5) x1 ) ) (- 29))) )) +(assert (= (+ (* (- 44) x3 ) (* (- 48) x1 ) (* 49 x0 ) (* (- 12) x0 ) (* (- 6) x4 ) (* (- 11) x0 ) ) 45) ) +(assert (not (>= (+ (* (- 20) x0 ) (* (- 5) x0 ) (* 43 x0 ) (* 33 x0 ) (* 35 x1 ) (* (- 30) x2 ) (* (- 4) x4 ) (* 22 x1 ) ) (- 50))) ) +(assert (not (> (+ (* 9 x1 ) (* 3 x2 ) (* 37 x1 ) (* (- 39) x4 ) ) 18)) ) +(assert (or (not (< (+ (* (- 23) x3 ) (* (- 10) x4 ) (* (- 17) x0 ) (* 19 x2 ) (* 40 x1 ) (* (- 19) x4 ) (* (- 32) x3 ) ) (- 5))) (not (= (+ (* 33 x2 ) (* (- 7) x2 ) (* 37 x2 ) (* 41 x1 ) (* (- 3) x2 ) (* 14 x1 ) (* 45 x0 ) (* (- 14) x1 ) ) 37)) (< (+ (* 3 x3 ) (* (- 26) x1 ) (* (- 24) x0 ) (* (- 20) x2 ) (* 23 x4 ) (* (- 28) x4 ) (* 42 x3 ) (* (- 19) x2 ) (* (- 26) x1 ) (* (- 40) x2 ) ) (- 27)) )) +(check-sat) +(push 1) +(assert (or (not (= (+ (* (- 24) x4 ) (* 7 x4 ) (* (- 12) x1 ) (* 30 x3 ) (* 26 x3 ) (* (- 45) x2 ) (* (- 3) x1 ) (* (- 7) x2 ) (* (- 14) x0 ) ) 10)) (not (>= (+ (* (- 21) x0 ) (* 31 x3 ) (* (- 16) x3 ) (* 22 x0 ) (* 5 x1 ) (* 31 x0 ) (* 8 x4 ) (* 13 x4 ) ) 40)) (not (>= (+ (* (- 38) x1 ) (* 45 x1 ) (* (- 31) x0 ) (* 18 x3 ) (* 0 x2 ) (* (- 32) x4 ) ) (- 19))) )) +(check-sat) +(pop 1) +(assert (not (= (+ (* 11 x3 ) (* (- 27) x0 ) (* 1 x0 ) ) (- 12))) ) +(check-sat) +(push 1) +(assert (or (= (+ (* 46 x3 ) (* (- 41) x4 ) (* (- 33) x4 ) (* 32 x2 ) (* (- 13) x2 ) (* 36 x3 ) (* (- 50) x3 ) (* 41 x2 ) (* 34 x4 ) ) (- 48)) (= (+ (* 17 x4 ) (* (- 43) x2 ) (* (- 2) x4 ) (* (- 38) x4 ) ) (- 8)) )) +(check-sat) +(push 1) +(assert (or (not (< (+ (* (- 15) x2 ) (* (- 15) x3 ) ) 24)) (not (< (+ (* (- 4) x1 ) (* 25 x2 ) (* 13 x4 ) (* 13 x2 ) (* (- 31) x0 ) (* 44 x2 ) (* 6 x3 ) (* (- 40) x3 ) (* (- 31) x1 ) (* (- 35) x4 ) ) 9)) )) +(check-sat) +(push 1) +(assert (or (= (+ (* 6 x1 ) (* 7 x3 ) (* (- 15) x2 ) (* 23 x3 ) (* (- 13) x3 ) (* 30 x4 ) (* (- 39) x2 ) (* 27 x4 ) ) 18) (not (< (+ (* (- 4) x4 ) (* (- 35) x1 ) (* 34 x4 ) (* (- 33) x3 ) (* 18 x2 ) (* 28 x0 ) (* (- 15) x4 ) ) 37)) )) +(assert (or (< (+ (* 43 x3 ) (* 17 x2 ) ) (- 45)) (<= (+ (* 37 x3 ) (* 19 x1 ) (* (- 8) x3 ) (* 49 x1 ) (* (- 14) x3 ) (* (- 30) x2 ) (* 14 x0 ) (* 31 x0 ) (* (- 13) x4 ) (* (- 28) x2 ) ) 8) )) +(assert (<= (+ (* (- 35) x2 ) (* (- 15) x3 ) (* (- 6) x0 ) (* 16 x4 ) (* (- 42) x3 ) (* (- 48) x0 ) (* 40 x2 ) (* 26 x3 ) (* 45 x0 ) (* 10 x0 ) ) 27) ) +(assert (or (<= (+ (* 12 x1 ) (* (- 33) x3 ) (* 17 x2 ) (* (- 7) x2 ) (* (- 25) x4 ) (* (- 22) x2 ) (* 2 x1 ) (* (- 46) x3 ) (* (- 2) x1 ) (* (- 5) x4 ) (* 7 x4 ) ) (- 10)) (not (>= (+ (* (- 31) x4 ) (* 25 x4 ) (* (- 33) x4 ) (* 9 x3 ) (* (- 48) x4 ) (* (- 31) x1 ) (* (- 18) x0 ) (* 34 x4 ) (* (- 15) x1 ) ) 39)) (not (<= (+ (* 36 x2 ) (* 24 x0 ) (* (- 17) x3 ) (* (- 38) x1 ) (* 2 x2 ) (* 11 x2 ) (* (- 39) x2 ) (* (- 33) x1 ) (* 15 x1 ) (* (- 1) x0 ) (* (- 33) x4 ) ) 32)) )) +(check-sat) +(push 1) +(assert (or (= (+ (* 44 x3 ) (* (- 19) x3 ) (* 38 x0 ) (* 13 x4 ) (* (- 32) x1 ) ) (- 35)) (>= (+ (* 13 x3 ) (* 21 x4 ) (* 34 x3 ) (* 15 x1 ) (* 5 x3 ) (* (- 43) x3 ) (* 11 x0 ) ) 0) )) +(assert (< (+ (* 14 x2 ) (* 38 x0 ) (* (- 42) x2 ) ) (- 44)) ) +(assert (or (not (< (+ (* (- 45) x1 ) (* 32 x3 ) (* 36 x1 ) (* 44 x2 ) (* 42 x3 ) (* (- 7) x2 ) (* 2 x1 ) (* (- 23) x1 ) (* 36 x0 ) (* (- 33) x3 ) ) 0)) (not (> (+ (* (- 34) x1 ) (* (- 49) x4 ) (* 15 x1 ) (* 10 x0 ) (* 10 x0 ) (* (- 39) x2 ) (* (- 9) x1 ) (* (- 11) x1 ) (* 10 x3 ) (* (- 11) x4 ) ) (- 38))) (<= (+ (* 10 x3 ) (* (- 34) x2 ) (* (- 13) x0 ) (* 19 x1 ) (* 20 x3 ) (* 9 x0 ) (* (- 33) x1 ) (* (- 44) x4 ) (* (- 37) x2 ) ) (- 32)) )) +(assert (or (<= (+ (* (- 50) x1 ) (* (- 50) x4 ) (* 48 x0 ) (* (- 5) x0 ) (* 40 x0 ) (* 20 x1 ) (* (- 43) x2 ) (* (- 18) x1 ) ) 28) (not (< (+ (* 13 x1 ) (* (- 41) x2 ) (* (- 8) x3 ) (* 33 x4 ) ) (- 32))) (not (< (+ (* 4 x3 ) (* (- 15) x2 ) (* (- 33) x2 ) (* 12 x1 ) (* (- 8) x2 ) ) 35)) )) +(assert (or (= (+ (* 12 x0 ) (* (- 28) x3 ) (* (- 28) x2 ) (* (- 45) x3 ) (* (- 31) x0 ) (* (- 15) x3 ) (* (- 39) x2 ) (* 28 x2 ) ) 16) (not (<= (+ (* 44 x3 ) (* 28 x0 ) (* 20 x4 ) ) 14)) (<= (+ (* 39 x3 ) (* 23 x2 ) (* 24 x3 ) ) 45) )) +(assert (or (not (<= (+ (* (- 10) x0 ) (* (- 8) x3 ) (* (- 49) x3 ) (* (- 19) x3 ) ) 22)) (= (+ (* 17 x3 ) (* (- 42) x4 ) (* 27 x0 ) (* 35 x0 ) (* 42 x3 ) ) 8) )) +(assert (or (not (>= (+ (* (- 5) x0 ) (* 20 x1 ) (* (- 45) x0 ) (* 5 x4 ) (* (- 43) x1 ) (* (- 20) x1 ) (* (- 34) x2 ) ) (- 11))) (not (<= (+ (* (- 5) x1 ) (* 21 x3 ) (* 16 x2 ) (* (- 10) x0 ) (* 35 x3 ) (* (- 23) x3 ) (* 18 x1 ) (* (- 42) x4 ) ) (- 12))) (not (= (+ (* 21 x4 ) (* (- 47) x1 ) (* 35 x4 ) (* (- 5) x1 ) (* (- 43) x1 ) (* (- 21) x1 ) (* 14 x4 ) (* 37 x0 ) (* 17 x2 ) (* 32 x4 ) (* 27 x2 ) ) (- 40))) )) +(assert (or (not (= (+ (* 14 x1 ) (* (- 38) x4 ) (* (- 48) x2 ) (* (- 9) x2 ) (* (- 11) x3 ) (* (- 9) x2 ) (* 5 x1 ) (* (- 48) x1 ) ) 21)) (not (> (+ (* (- 29) x1 ) (* 45 x1 ) (* 48 x0 ) (* (- 2) x1 ) (* 35 x4 ) ) (- 15))) (not (= (+ (* (- 13) x0 ) (* 14 x1 ) (* (- 31) x0 ) (* 19 x3 ) ) (- 37))) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* 0 x4 ) (* (- 13) x1 ) (* (- 33) x3 ) (* 34 x2 ) (* (- 27) x2 ) (* (- 46) x0 ) (* 21 x1 ) ) (- 17))) (<= (+ (* 41 x2 ) (* 23 x1 ) (* (- 1) x0 ) (* 35 x4 ) (* 28 x3 ) ) (- 18)) )) +(assert (or (not (= (+ (* 43 x2 ) (* (- 41) x1 ) (* 30 x3 ) (* (- 50) x3 ) (* (- 9) x0 ) ) (- 27))) (>= (+ (* (- 35) x0 ) (* 22 x0 ) ) 38) (not (> (+ (* 9 x2 ) (* (- 45) x3 ) (* 19 x2 ) (* 49 x0 ) (* (- 37) x2 ) (* (- 27) x3 ) (* (- 27) x4 ) ) (- 46))) )) +(assert (or (> (+ (* (- 4) x1 ) (* 49 x2 ) (* 7 x2 ) ) (- 27)) (not (< (+ (* (- 33) x0 ) (* (- 39) x0 ) (* 9 x4 ) (* (- 33) x0 ) ) 9)) (>= (+ (* 6 x3 ) (* 22 x4 ) (* 4 x1 ) (* (- 34) x0 ) ) (- 46)) )) +(assert (not (>= (+ (* 0 x1 ) (* (- 9) x1 ) (* (- 1) x2 ) (* 4 x1 ) (* (- 13) x0 ) (* (- 10) x4 ) (* (- 25) x4 ) (* (- 14) x3 ) (* (- 49) x1 ) ) 43)) ) +(assert (or (<= (+ (* 20 x2 ) (* 42 x3 ) (* (- 4) x2 ) (* (- 44) x3 ) (* (- 45) x1 ) (* 45 x2 ) (* (- 40) x4 ) (* 16 x0 ) (* (- 34) x3 ) (* 4 x1 ) (* 41 x1 ) ) 41) (< (+ (* 19 x4 ) (* (- 50) x0 ) (* (- 28) x4 ) (* (- 20) x0 ) ) 17) )) +(assert (or (< (+ (* 35 x0 ) (* 1 x2 ) ) 46) (not (>= (+ (* 26 x0 ) (* 33 x3 ) (* (- 9) x2 ) (* 10 x2 ) (* 41 x2 ) (* (- 28) x1 ) ) 41)) (not (> (+ (* (- 34) x3 ) (* 1 x3 ) (* (- 19) x1 ) ) (- 23))) )) +(assert (or (not (> (+ (* 25 x0 ) (* 17 x4 ) (* 9 x3 ) ) (- 48))) (not (>= (+ (* (- 20) x2 ) (* 14 x0 ) ) (- 45))) )) +(assert (not (<= (+ (* 2 x3 ) (* (- 24) x3 ) (* (- 40) x1 ) (* 3 x0 ) ) (- 36))) ) +(assert (not (= (+ (* (- 30) x4 ) (* 11 x1 ) (* (- 11) x0 ) ) (- 29))) ) +(assert (not (= (+ (* 44 x4 ) (* (- 22) x4 ) (* 49 x1 ) (* (- 41) x0 ) (* 18 x2 ) ) 21)) ) +(check-sat) +(pop 1) +(assert (not (= (+ (* 38 x3 ) (* 7 x2 ) (* (- 23) x4 ) (* (- 28) x3 ) (* 20 x2 ) (* 39 x3 ) (* 17 x2 ) (* 28 x0 ) (* 11 x2 ) (* 29 x4 ) (* (- 43) x0 ) ) (- 2))) ) +(assert (not (>= (+ (* 6 x1 ) (* 29 x3 ) (* 25 x4 ) (* (- 4) x3 ) (* (- 13) x4 ) (* 9 x0 ) (* (- 32) x2 ) (* (- 45) x3 ) (* (- 14) x2 ) (* 34 x3 ) (* (- 37) x2 ) ) 14)) ) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (>= (+ (* (- 50) x2 ) (* 48 x1 ) (* 16 x0 ) (* 31 x4 ) (* (- 33) x3 ) ) (- 10)) (not (< (+ (* (- 25) x3 ) (* (- 47) x4 ) (* (- 24) x1 ) (* 27 x3 ) (* 42 x3 ) ) (- 9))) )) +(check-sat) +(pop 1) +(assert (or (not (> (+ (* 49 x0 ) (* (- 28) x3 ) (* (- 47) x1 ) (* (- 29) x1 ) (* (- 2) x0 ) (* (- 43) x4 ) (* (- 46) x4 ) ) 34)) (> (+ (* (- 22) x2 ) (* 45 x0 ) ) (- 29)) )) +(push 1) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (<= (+ (* (- 22) x4 ) (* (- 39) x1 ) (* (- 9) x1 ) (* (- 32) x1 ) (* 5 x2 ) (* 7 x3 ) (* (- 13) x3 ) (* 31 x3 ) ) 35) (<= (+ (* 44 x2 ) (* 21 x3 ) (* (- 9) x1 ) ) (- 29)) )) +(assert (or (not (>= (+ (* 22 x1 ) (* (- 1) x2 ) (* (- 47) x0 ) (* 12 x4 ) (* (- 42) x4 ) ) 22)) (not (<= (+ (* 32 x0 ) (* 45 x1 ) (* 40 x4 ) (* 44 x4 ) (* 3 x2 ) (* 33 x2 ) ) (- 17))) )) +(check-sat) +(pop 1) +(assert (or (not (> (+ (* (- 26) x1 ) (* 26 x0 ) ) 48)) (>= (+ (* 35 x3 ) (* (- 43) x2 ) (* 29 x0 ) (* (- 31) x2 ) (* (- 20) x2 ) (* 22 x1 ) ) 49) (>= (+ (* (- 31) x2 ) (* (- 2) x1 ) (* (- 45) x2 ) (* 25 x2 ) (* 29 x4 ) (* (- 23) x1 ) (* (- 1) x0 ) (* 18 x1 ) (* 0 x2 ) (* (- 43) x2 ) (* 24 x2 ) ) (- 23)) )) +(assert (or (<= (+ (* 5 x0 ) (* (- 8) x0 ) (* 18 x4 ) (* (- 12) x3 ) (* (- 18) x3 ) (* (- 48) x3 ) (* (- 34) x1 ) (* (- 2) x1 ) (* (- 50) x3 ) (* (- 45) x3 ) ) (- 48)) (>= (+ (* 41 x0 ) (* 25 x2 ) (* (- 17) x2 ) (* (- 6) x0 ) (* (- 48) x3 ) (* (- 36) x3 ) (* 31 x0 ) (* (- 7) x3 ) ) 15) )) +(check-sat) + diff --git a/test/regress/regress1/push-pop/arith_lra_02.smt2 b/test/regress/regress1/push-pop/arith_lra_02.smt2 new file mode 100644 index 000000000..3cb5674d1 --- /dev/null +++ b/test/regress/regress1/push-pop/arith_lra_02.smt2 @@ -0,0 +1,95 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(assert (or (not (>= (+ (* (- 29) x2 ) (* 3 x2 ) (* 49 x0 ) (* 46 x1 ) (* (- 18) x0 ) (* (- 17) x2 ) (* 35 x0 ) (* 9 x2 ) (* (- 16) x0 ) ) 16)) (= (+ (* 25 x1 ) (* 15 x2 ) (* 27 x4 ) (* 7 x2 ) (* 27 x3 ) (* (- 45) x4 ) ) (- 20)) (not (< (+ (* (- 13) x3 ) (* 47 x3 ) (* 20 x3 ) ) 33)) )) +(check-sat) +(assert (or (not (<= (+ (* (- 35) x1 ) (* 11 x4 ) ) (- 21))) (not (< (+ (* 12 x1 ) (* (- 24) x2 ) (* (- 41) x4 ) (* 25 x3 ) (* (- 29) x4 ) ) 41)) )) +(assert (or (not (>= (+ (* (- 3) x1 ) (* (- 12) x0 ) (* 29 x4 ) ) 0)) (>= (+ (* (- 27) x3 ) (* (- 15) x2 ) (* (- 30) x0 ) (* 29 x0 ) (* 44 x2 ) (* (- 20) x0 ) (* (- 9) x2 ) ) (- 47)) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* (- 30) x2 ) (* (- 42) x0 ) (* (- 30) x4 ) (* (- 4) x0 ) (* (- 5) x4 ) (* (- 12) x4 ) (* (- 18) x4 ) (* 15 x0 ) ) 32)) (> (+ (* 44 x2 ) (* (- 37) x0 ) (* (- 35) x0 ) (* (- 1) x3 ) (* 25 x2 ) (* (- 39) x0 ) (* 40 x0 ) (* 7 x4 ) (* (- 20) x2 ) (* 27 x3 ) (* (- 50) x2 ) ) 17) )) +(check-sat) +(push 1) +(assert (or (= (+ (* 47 x4 ) (* (- 1) x1 ) (* 39 x4 ) (* (- 44) x0 ) ) (- 34)) (>= (+ (* 39 x0 ) (* 7 x1 ) (* (- 26) x1 ) (* 48 x1 ) ) 26) )) +(check-sat) +(push 1) +(assert (or (= (+ (* (- 25) x2 ) (* 16 x4 ) (* (- 13) x4 ) (* (- 12) x2 ) ) 29) (not (= (+ (* 13 x2 ) (* (- 33) x1 ) (* (- 18) x2 ) (* 26 x4 ) (* (- 37) x4 ) (* (- 13) x4 ) (* (- 2) x3 ) (* (- 7) x3 ) (* 26 x3 ) (* (- 20) x2 ) (* (- 27) x1 ) ) (- 2))) )) +(assert (or (>= (+ (* (- 7) x0 ) (* (- 15) x1 ) (* 35 x3 ) ) 11) (= (+ (* (- 21) x0 ) (* (- 1) x4 ) (* 21 x3 ) (* (- 6) x2 ) (* (- 49) x0 ) ) (- 15)) (not (< (+ (* 47 x3 ) (* (- 47) x4 ) (* 3 x0 ) (* 16 x3 ) (* (- 21) x1 ) (* 1 x3 ) (* 16 x2 ) ) (- 25))) )) +(assert (> (+ (* (- 7) x1 ) (* (- 20) x1 ) (* (- 1) x2 ) (* 24 x3 ) (* (- 14) x4 ) (* 24 x2 ) (* 38 x4 ) (* (- 44) x2 ) (* (- 50) x1 ) ) 22) ) +(assert (not (>= (+ (* 16 x1 ) (* (- 43) x4 ) (* (- 22) x3 ) (* 11 x0 ) (* (- 22) x3 ) (* (- 40) x2 ) (* 25 x2 ) ) (- 13))) ) +(assert (or (not (> (+ (* (- 5) x3 ) (* (- 46) x4 ) (* (- 21) x2 ) (* 29 x1 ) (* 38 x4 ) (* 48 x3 ) ) (- 44))) (not (<= (+ (* (- 13) x0 ) (* (- 42) x3 ) (* 27 x2 ) (* 45 x1 ) (* (- 42) x3 ) (* (- 33) x3 ) ) (- 16))) (not (= (+ (* 21 x3 ) (* 0 x4 ) (* (- 50) x0 ) (* (- 43) x0 ) (* (- 40) x3 ) (* 45 x2 ) (* (- 36) x2 ) (* 2 x2 ) (* 2 x3 ) (* (- 30) x2 ) ) (- 20))) )) +(assert (or (not (< (+ (* 28 x2 ) (* 21 x4 ) (* 19 x0 ) (* 31 x2 ) (* 45 x1 ) (* 3 x4 ) (* 24 x4 ) ) (- 34))) (not (> (+ (* (- 10) x2 ) (* (- 18) x2 ) (* 49 x3 ) (* (- 27) x2 ) (* (- 30) x3 ) ) 8)) (= (+ (* 42 x1 ) (* (- 18) x3 ) (* (- 23) x3 ) (* 34 x0 ) (* 49 x4 ) (* 30 x0 ) (* (- 44) x4 ) (* 45 x3 ) ) 39) )) +(assert (or (< (+ (* (- 41) x2 ) (* (- 40) x4 ) (* (- 36) x4 ) (* 7 x4 ) (* (- 5) x3 ) (* 11 x1 ) (* 16 x4 ) (* (- 3) x0 ) ) (- 48)) (= (+ (* 22 x0 ) (* 41 x3 ) (* (- 11) x0 ) (* (- 42) x3 ) (* 18 x0 ) (* (- 7) x4 ) (* (- 5) x2 ) ) (- 45)) (not (< (+ (* (- 11) x2 ) (* (- 30) x4 ) (* (- 25) x2 ) (* 42 x1 ) (* (- 10) x2 ) (* 21 x2 ) (* 5 x3 ) (* (- 19) x3 ) (* (- 35) x1 ) (* 11 x3 ) ) (- 27))) )) +(assert (or (not (> (+ (* 41 x4 ) (* (- 30) x3 ) (* (- 15) x4 ) (* 35 x1 ) (* 13 x0 ) (* 43 x3 ) ) 6)) (<= (+ (* (- 31) x3 ) (* 4 x2 ) (* 18 x0 ) (* 23 x4 ) (* 43 x0 ) (* (- 39) x4 ) (* (- 1) x2 ) ) (- 28)) (<= (+ (* 32 x1 ) (* (- 47) x1 ) (* (- 17) x4 ) (* 32 x3 ) (* 24 x4 ) (* 15 x0 ) (* (- 22) x2 ) (* 14 x4 ) (* 36 x2 ) (* 2 x0 ) (* (- 35) x2 ) ) (- 5)) )) +(check-sat) +(push 1) +(assert (or (not (= (+ (* (- 33) x3 ) (* 19 x4 ) ) 22)) (<= (+ (* 35 x3 ) (* (- 22) x0 ) (* 9 x0 ) (* (- 16) x1 ) (* 41 x3 ) (* (- 42) x3 ) (* 35 x3 ) ) 25) (not (>= (+ (* (- 8) x1 ) (* 22 x1 ) ) 14)) )) +(assert (or (< (+ (* 27 x1 ) (* 4 x1 ) ) 12) (<= (+ (* (- 8) x2 ) (* (- 47) x4 ) (* (- 26) x3 ) (* (- 22) x1 ) (* (- 11) x4 ) (* (- 28) x3 ) (* 17 x3 ) (* 1 x0 ) (* 31 x4 ) (* 30 x3 ) ) (- 48)) (not (> (+ (* (- 6) x0 ) (* (- 35) x4 ) (* (- 12) x0 ) (* (- 6) x0 ) (* (- 19) x2 ) ) (- 3))) )) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (<= (+ (* 7 x4 ) (* (- 25) x1 ) (* 49 x3 ) (* (- 10) x0 ) (* 48 x0 ) (* (- 23) x0 ) (* 44 x4 ) (* (- 39) x2 ) (* 24 x4 ) ) 6) (<= (+ (* (- 36) x2 ) (* (- 17) x1 ) (* 18 x1 ) (* (- 27) x0 ) (* 36 x3 ) (* 12 x2 ) (* 21 x1 ) (* 18 x3 ) (* 38 x3 ) (* (- 44) x1 ) (* (- 37) x3 ) ) 2) (= (+ (* (- 18) x2 ) (* 45 x1 ) (* 43 x3 ) (* (- 44) x1 ) ) 28) )) +(assert (= (+ (* (- 2) x2 ) (* 31 x4 ) (* 20 x1 ) ) (- 1)) ) +(assert (not (> (+ (* 47 x3 ) (* 7 x1 ) (* (- 20) x4 ) (* 42 x0 ) (* (- 20) x2 ) (* (- 12) x2 ) (* (- 34) x3 ) (* (- 35) x2 ) (* 0 x4 ) (* 18 x0 ) ) 49)) ) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (< (+ (* (- 46) x0 ) (* (- 32) x4 ) (* 40 x3 ) (* (- 47) x0 ) (* 27 x0 ) (* 22 x0 ) (* (- 24) x2 ) (* 0 x0 ) (* (- 11) x3 ) ) (- 50))) ) +(check-sat) +(push 1) +(assert (or (>= (+ (* 37 x2 ) (* 33 x1 ) (* 29 x1 ) (* (- 48) x4 ) (* 3 x2 ) (* 48 x2 ) (* (- 23) x3 ) (* 44 x2 ) (* 45 x2 ) (* (- 6) x2 ) (* 15 x2 ) ) 34) (not (>= (+ (* (- 11) x1 ) (* (- 23) x0 ) (* (- 32) x0 ) (* 49 x1 ) (* 14 x3 ) (* 43 x3 ) (* (- 23) x1 ) (* 9 x1 ) (* (- 44) x2 ) ) (- 12))) (= (+ (* (- 26) x2 ) (* (- 1) x2 ) (* (- 27) x0 ) (* (- 39) x3 ) (* 49 x4 ) (* (- 26) x0 ) (* (- 3) x3 ) ) 44) )) +(assert (not (>= (+ (* (- 22) x3 ) (* 41 x4 ) (* 31 x4 ) (* (- 21) x2 ) (* 0 x3 ) (* (- 8) x2 ) (* 9 x4 ) (* (- 34) x1 ) (* (- 8) x4 ) (* 3 x2 ) ) 43)) ) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (= (+ (* 15 x0 ) (* (- 46) x0 ) (* (- 49) x3 ) (* (- 45) x0 ) (* 26 x1 ) ) 5) (= (+ (* 12 x4 ) (* (- 2) x3 ) (* (- 24) x4 ) (* (- 1) x1 ) (* (- 20) x0 ) ) 23) )) +(assert (< (+ (* (- 42) x4 ) (* 41 x3 ) (* 1 x2 ) (* (- 1) x3 ) (* (- 26) x2 ) (* 14 x0 ) ) (- 23)) ) +(assert (or (= (+ (* (- 36) x1 ) (* 44 x3 ) (* (- 20) x3 ) (* 39 x4 ) (* (- 19) x2 ) ) (- 15)) (not (>= (+ (* 3 x0 ) (* 49 x3 ) (* (- 49) x1 ) (* (- 37) x0 ) (* 28 x0 ) (* (- 46) x0 ) (* (- 22) x4 ) ) 47)) )) +(assert (<= (+ (* (- 37) x4 ) (* 10 x3 ) ) 4) ) +(assert (or (not (< (+ (* (- 38) x1 ) (* (- 36) x4 ) ) (- 39))) (not (> (+ (* 42 x1 ) (* 8 x1 ) ) (- 2))) (<= (+ (* (- 38) x4 ) (* (- 1) x2 ) (* 21 x4 ) (* (- 3) x3 ) (* 19 x4 ) (* 25 x2 ) (* 24 x4 ) ) (- 22)) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* 23 x3 ) (* 4 x4 ) (* 43 x1 ) (* 19 x2 ) (* 23 x0 ) (* 28 x3 ) (* 48 x3 ) (* (- 12) x1 ) (* 35 x0 ) (* (- 7) x2 ) (* (- 31) x3 ) ) (- 33))) (not (< (+ (* (- 29) x1 ) (* 23 x0 ) (* 20 x3 ) ) (- 4))) (not (>= (+ (* 49 x3 ) (* 3 x3 ) (* (- 18) x2 ) (* (- 3) x3 ) (* 35 x0 ) (* (- 23) x2 ) (* (- 5) x2 ) (* (- 15) x0 ) (* (- 10) x1 ) (* (- 45) x4 ) ) (- 2))) )) +(check-sat) +(push 1) +(check-sat) +(assert (or (>= (+ (* (- 11) x1 ) (* 38 x4 ) (* (- 29) x1 ) ) (- 21)) (not (>= (+ (* (- 16) x4 ) (* (- 43) x2 ) (* (- 10) x0 ) (* 38 x1 ) (* (- 1) x2 ) (* (- 3) x2 ) ) 25)) )) +(assert (or (not (< (+ (* (- 45) x4 ) (* (- 9) x0 ) (* (- 29) x2 ) (* (- 35) x1 ) (* (- 40) x2 ) (* 25 x1 ) (* (- 20) x2 ) (* (- 16) x1 ) ) 39)) (= (+ (* (- 10) x4 ) (* 9 x1 ) (* 16 x4 ) ) 5) (not (< (+ (* 34 x4 ) (* 17 x3 ) (* (- 8) x2 ) ) 38)) )) +(assert (or (not (<= (+ (* 13 x3 ) (* 22 x2 ) (* 1 x4 ) (* 26 x3 ) (* (- 15) x3 ) ) 18)) (> (+ (* (- 49) x3 ) (* 28 x4 ) (* (- 20) x4 ) (* (- 16) x4 ) (* 42 x2 ) (* 36 x2 ) (* 36 x3 ) (* (- 26) x4 ) ) 17) )) +(assert (or (not (= (+ (* (- 13) x1 ) (* (- 24) x0 ) (* (- 16) x2 ) (* (- 32) x3 ) (* (- 32) x2 ) (* 13 x4 ) (* (- 42) x3 ) (* 12 x3 ) (* 41 x4 ) (* 21 x1 ) (* (- 41) x4 ) ) 8)) (<= (+ (* 24 x1 ) (* 35 x1 ) ) 13) )) +(assert (< (+ (* (- 21) x0 ) (* (- 41) x4 ) (* (- 15) x2 ) ) 22) ) +(assert (or (not (>= (+ (* (- 34) x0 ) (* (- 9) x1 ) (* 21 x2 ) (* 13 x1 ) (* (- 25) x3 ) (* 4 x4 ) (* (- 45) x0 ) (* 34 x4 ) (* 10 x1 ) ) 32)) (not (> (+ (* (- 10) x2 ) (* 36 x0 ) (* 30 x2 ) (* 46 x3 ) (* (- 34) x1 ) ) 14)) )) +(assert (not (< (+ (* (- 45) x2 ) (* (- 3) x3 ) (* 38 x0 ) (* (- 44) x2 ) (* 40 x4 ) (* 8 x1 ) ) (- 7))) ) +(assert (not (> (+ (* 36 x3 ) (* 48 x0 ) (* (- 4) x4 ) (* 49 x4 ) (* (- 26) x1 ) (* (- 12) x3 ) (* (- 48) x0 ) ) (- 6))) ) +(check-sat) +(pop 1) +(assert (or (>= (+ (* 30 x0 ) (* (- 12) x4 ) (* 39 x4 ) (* (- 12) x0 ) (* (- 12) x2 ) (* 9 x1 ) (* (- 40) x2 ) ) 7) (not (> (+ (* 4 x2 ) (* 2 x2 ) (* 23 x4 ) ) (- 43))) )) +(check-sat) +(pop 1) +(check-sat) + diff --git a/test/regress/regress1/push-pop/bug-fmf-fun-skolem.smt2 b/test/regress/regress1/push-pop/bug-fmf-fun-skolem.smt2 new file mode 100644 index 000000000..229a5e17a --- /dev/null +++ b/test/regress/regress1/push-pop/bug-fmf-fun-skolem.smt2 @@ -0,0 +1,25 @@ +; COMMAND-LINE: --incremental --fmf-fun +(set-logic ALL_SUPPORTED) +(declare-datatypes ((Lst 0)) (((cons (head Int) (tail Lst)) (nil)))) +(define-fun-rec sum ((l Lst)) Int (ite (is-nil l) 0 (+ (head l) (sum (tail l))))) + +(declare-fun input () Int) +(declare-fun p () Bool) +(declare-fun acc () Lst) +(assert (and (= acc (ite (>= input 0) (cons input nil) nil)) + (= p (>= (sum acc) 0)))) + + +; EXPECT: unsat +(push 1) +(assert (not p)) +(check-sat) +(pop 1) + +; EXPECT: unsat +(push 1) +(assert (not p)) +(check-sat) +(pop 1) + + diff --git a/test/regress/regress1/push-pop/bug216.smt2 b/test/regress/regress1/push-pop/bug216.smt2 new file mode 100644 index 000000000..78e0f716c --- /dev/null +++ b/test/regress/regress1/push-pop/bug216.smt2 @@ -0,0 +1,8 @@ +(set-logic QF_UF) +(declare-fun x () Bool) +(declare-fun y () Bool) +(assert (=> x y)) +(check-sat) ; returns sat +(assert (=> y x)) +(assert (and x (not y))) +(check-sat) ; returns sat --> ERROR diff --git a/test/regress/regress1/push-pop/bug216.smt2.expect b/test/regress/regress1/push-pop/bug216.smt2.expect new file mode 100644 index 000000000..fe118171a --- /dev/null +++ b/test/regress/regress1/push-pop/bug216.smt2.expect @@ -0,0 +1,3 @@ +% COMMAND-LINE: --incremental +% EXPECT: sat +% EXPECT: unsat diff --git a/test/regress/regress1/push-pop/bug326.smt2 b/test/regress/regress1/push-pop/bug326.smt2 new file mode 100644 index 000000000..f1506b3e8 --- /dev/null +++ b/test/regress/regress1/push-pop/bug326.smt2 @@ -0,0 +1,41 @@ +; COMMAND-LINE: --incremental --rewrite-rules + +(set-logic AUFLIA) + +(declare-fun R (Int Int) Bool) + +;; reflexive +(assert-rewrite ((x Int)) () () (R x x) true) + +;; anti-symmetric +(assert-reduction ((x Int) (y Int)) () () ((R x y) (R y x)) (= x y)) + +;; transitive +(assert-propagation ((x Int) (y Int) (z Int)) () () ((R x y) (R y z)) (R x z)) + + +(declare-fun e1 () Int) +(declare-fun e2 () Int) +(declare-fun e3 () Int) +(declare-fun e4 () Int) + +; EXPECT: unsat +(push);;unsat +(assert (not (=> (and (R e1 e2) (R e2 e4) (R e1 e3) (R e3 e4) (= e1 e4)) (= e2 e3)))) +(check-sat) +(pop) + +; EXPECT: unsat +(push);;unsat +(assert (not (=> (and (R e1 e2) (R e1 e3) (or (R e2 e4) (R e3 e4)) ) (R e1 e4)))) +(check-sat) +(pop) + +; EXPECT: sat +(push);;sat +(assert (and (not (R e1 e3)) (R e4 e1))) +(check-sat) +(pop) + + +(exit) diff --git a/test/regress/regress1/push-pop/fuzz_1.smt2 b/test/regress/regress1/push-pop/fuzz_1.smt2 new file mode 100644 index 000000000..0af648d26 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_1.smt2 @@ -0,0 +1,62 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (or (and (or (and (and (or (and (and (and x6 x1) (not x7)) (not (and x5 x9))) (or (or (and x8 x7) (or x5 x4)) (and (and x3 x2) (and x2 x9)))) (and (or (not (or x8 x3)) (and (or x1 x0) (not x9))) (or (or (and x7 x1) (not x5)) (not (and x1 x8))))) (not (and (and (or (and x4 x2) (or x5 x5)) (and (and x4 x6) (not x8))) (and (or (or x7 x4) (and x3 x1)) (or (and x8 x7) (or x9 x8)))))) (or (or (or (and (not (not x6)) (or (and x1 x5) (or x5 x2))) (or (not (or x3 x1)) (and (not x3) (or x0 x9)))) (and (or (not (or x0 x7)) (or (or x8 x3) (or x5 x9))) (or (or (not x3) (and x0 x5)) (and (or x7 x8) (or x6 x7))))) (not (not (not (and (and x0 x3) (and x1 x0))))))) (and (and (or (and (and (not (not x0)) (or (or x3 x4) (and x0 x9))) (not (not (and x1 x5)))) (not (not (or (and x7 x5) (not x0))))) (or (not (and (or (or x0 x9) (not x8)) (not (and x4 x5)))) (not (or (and (and x9 x3) (not x8)) (or (or x4 x9) (and x9 x7)))))) (and (or (not (and (not (not x8)) (or (not x8) (or x2 x1)))) (or (or (not (not x6)) (and (and x5 x2) (or x3 x8))) (not (and (or x7 x7) (or x5 x2))))) (or (or (and (not (not x2)) (and (or x2 x9) (or x8 x5))) (or (or (and x3 x4) (and x7 x5)) (and (not x1) (not x6)))) (or (or (and (not x4) (and x3 x3)) (and (not x5) (or x7 x9))) (not (and (not x8) (and x5 x0)))))))) (or (not (or (or (not (and (or (not x5) (and x0 x6)) (not (not x0)))) (and (not (or (or x5 x1) (or x4 x0))) (and (not (or x4 x9)) (or (or x4 x1) (or x7 x8))))) (or (or (not (or (and x2 x3) (and x1 x4))) (not (and (and x2 x3) (or x5 x7)))) (not (not (or (or x7 x9) (and x3 x5))))))) (not (not (or (not (or (or (not x0) (not x9)) (or (or x3 x9) (or x9 x1)))) (or (and (not (not x1)) (and (and x9 x3) (or x0 x8))) (or (and (and x3 x7) (or x6 x8)) (not (or x9 x1)))))))))) +(check-sat) +(push 1) +(assert (and (not (or (not (or (not (not x3)) (and (and x2 x3) (and x9 x3)))) (or (or (or (and x5 x8) (and x4 x6)) (not (or x7 x3))) (not (and (or x8 x6) (and x4 x7)))))) (or (or (not (not (or (and x5 x1) (or x8 x3)))) (and (not (and (not x5) (not x1))) (or (not (not x0)) (not (not x6))))) (or (and (not (and (or x1 x2) (and x5 x4))) (and (not (and x3 x9)) (or (not x9) (not x7)))) (and (not (and (or x6 x2) (or x9 x9))) (or (and (not x9) (or x4 x4)) (not (and x4 x7)))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (not (and (not (and (or (not (not x7)) (or (and x6 x1) (not x6))) (or (and (or x4 x3) (not x3)) (or (or x4 x1) (not x4))))) (not (or (and (not (not x4)) (not (and x5 x6))) (not (and (or x2 x1) (or x3 x7)))))))))) +(check-sat) +(push 1) +(assert (not (and (not (not x1)) (or (or x8 x7) (and x1 x2))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (or x6 x2))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (and (not (and (and x3 x6) (and x6 x9))) (not (or (and x1 x6) (and x5 x1)))) (and (not (or (and x2 x8) (not x4))) (or (not (not x3)) (or (not x3) (or x1 x7)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (or (not (and (not (not (and (not (not x5)) (or (not x3) (or x1 x7))))) (not (or (or (or (and x8 x9) (or x6 x8)) (or (not x6) (not x2))) (not (and (not x8) (or x3 x9))))))) (or (and (and (and (and (and (and x7 x9) (and x3 x2)) (not (and x1 x4))) (and (not (not x1)) (and (or x8 x3) (or x3 x4)))) (and (and (or (and x4 x6) (and x9 x2)) (not (or x9 x1))) (not (and (or x6 x8) (not x2))))) (and (and (or (and (or x1 x2) (and x4 x8)) (or (or x7 x4) (or x3 x1))) (and (not (not x2)) (or (and x3 x0) (not x9)))) (not (not (not (not x1)))))) (and (or (not (not (or (or x2 x9) (or x8 x8)))) (or (or (not (and x5 x2)) (not (or x4 x5))) (and (not (or x6 x9)) (not (not x7))))) (not (and (not (not (or x5 x4))) (and (or (and x1 x7) (or x2 x2)) (not (not x9))))))))))) +(assert (not (or (and (or (or x6 x2) (and x9 x1)) (and (not x3) (and x8 x2))) (or (and (or x0 x0) (not x7)) (and (not x1) (and x7 x1)))))) +(check-sat) +(pop 1) +(assert (and (or (not (or (or (or (not (not (and x9 x8))) (and (not (and x6 x4)) (and (or x6 x2) (and x4 x2)))) (and (or (and (and x1 x4) (and x1 x8)) (and (or x6 x0) (or x8 x6))) (or (and (not x8) (and x7 x6)) (or (not x5) (not x7))))) (and (or (or (not (or x5 x5)) (and (and x3 x8) (not x9))) (and (or (or x6 x6) (or x0 x6)) (or (and x5 x1) (not x9)))) (or (and (or (and x5 x6) (not x9)) (not (not x6))) (or (not (and x9 x3)) (not (not x1))))))) (and (and (or (and (and (and (and x6 x3) (or x5 x5)) (or (and x7 x8) (and x3 x6))) (and (and (not x2) (not x7)) (not (and x2 x2)))) (or (not (and (not x5) (not x5))) (and (and (not x7) (and x8 x2)) (not (and x9 x1))))) (or (not (or (and (not x9) (not x0)) (and (not x8) (and x8 x5)))) (not (not (not (not x5)))))) (or (not (or (or (or (not x4) (and x1 x3)) (or (and x6 x1) (not x5))) (not (not (not x4))))) (and (and (or (not (or x9 x8)) (or (not x0) (and x9 x5))) (and (not (not x4)) (not (or x5 x8)))) (and (and (or (and x2 x1) (not x3)) (and (and x5 x6) (not x8))) (not (or (not x1) (not x8)))))))) (and (or (and (and (or (or (and (or x1 x5) (not x3)) (and (not x9) (not x3))) (and (and (or x1 x0) (or x2 x8)) (or (not x7) (and x0 x7)))) (or (or (and (and x1 x7) (or x4 x1)) (and (or x4 x9) (and x3 x9))) (not (and (not x8) (and x4 x2))))) (and (or (and (or (or x9 x5) (not x7)) (or (or x8 x9) (or x6 x4))) (and (not (not x1)) (or (and x7 x3) (or x0 x7)))) (or (or (and (not x6) (not x2)) (and (not x1) (and x8 x0))) (not (or (and x1 x8) (and x7 x3)))))) (and (and (or (and (or (or x6 x3) (not x5)) (not (not x9))) (and (or (or x5 x0) (and x8 x5)) (and (and x7 x0) (and x0 x9)))) (not (or (and (and x9 x1) (and x6 x7)) (and (or x4 x3) (or x7 x4))))) (and (or (not (and (or x5 x4) (or x1 x4))) (not (and (or x3 x1) (or x2 x7)))) (not (and (or (or x0 x6) (not x4)) (and (or x0 x0) (not x1))))))) (and (not (and (not (not (and (not x9) (and x2 x1)))) (and (not (or (or x0 x1) (not x4))) (not (or (not x1) (not x1)))))) (not (or (not (or (not (or x4 x6)) (not (not x4)))) (and (or (and (not x7) (not x3)) (or (not x4) (or x3 x6))) (and (and (and x9 x9) (and x2 x2)) (not (or x8 x4)))))))))) +(assert (and (and (or x9 x9) (or x2 x7)) (and (and x0 x3) (and x5 x2)))) +(assert (and (and (or (or x2 x2) (or x5 x2)) (and (or x6 x3) (or x1 x8))) (or (not (or x6 x4)) (or (or x2 x7) (or x4 x4))))) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_10.smt2 b/test/regress/regress1/push-pop/fuzz_10.smt2 new file mode 100644 index 000000000..53493d261 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_10.smt2 @@ -0,0 +1,62 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (not (and (or x4 x1) (and x5 x3))) (not (or (not x3) (not x3))))) +(assert (and (or (not (and (or (or x1 x0) (not x0)) (and (not x1) (and x5 x2)))) (not (and (and (and x3 x4) (and x0 x6)) (or (not x1) (and x4 x5))))) (or (or (and (not (and x1 x5)) (not (not x5))) (and (and (and x0 x6) (and x0 x4)) (not (not x5)))) (not (and (and (not x6) (and x0 x0)) (and (not x2) (not x2))))))) +(assert (or (not (or x6 x1)) (and (or x5 x1) (or x5 x6)))) +(assert (not (or (and (and (or (not (not (and x1 x0))) (not (and (or x1 x4) (or x6 x6)))) (not (not (not (or x4 x6))))) (and (or (or (or (and x2 x6) (and x1 x2)) (or (not x3) (not x3))) (or (or (and x4 x3) (and x2 x3)) (not (not x0)))) (and (not (and (and x4 x3) (not x2))) (or (and (or x0 x2) (not x2)) (or (not x3) (or x3 x3)))))) (and (not (not (or (or (or x5 x3) (or x4 x4)) (not (and x0 x6))))) (and (or (not (and (and x4 x5) (and x2 x6))) (or (and (and x2 x1) (and x3 x0)) (and (and x5 x4) (and x6 x2)))) (and (and (and (not x6) (not x4)) (and (and x0 x6) (not x4))) (not (and (or x4 x3) (not x6))))))))) +(assert (and (or (not (not (not (and (not (and x3 x0)) (and (or x6 x1) (not x1)))))) (not (and (not (or (and (or x3 x5) (and x0 x6)) (or (not x1) (not x4)))) (not (and (and (not x6) (and x1 x2)) (and (and x3 x0) (and x6 x0))))))) (or (not (or (and (and (or (and x1 x4) (not x0)) (not (and x6 x3))) (or (and (or x2 x6) (and x3 x5)) (not (not x0)))) (or (or (not (and x1 x6)) (or (or x3 x3) (and x0 x2))) (or (not (not x0)) (and (or x2 x6) (and x1 x6)))))) (not (and (and (and (or (and x0 x4) (and x3 x4)) (and (or x2 x6) (or x4 x4))) (or (and (or x3 x0) (or x5 x6)) (not (or x4 x0)))) (and (and (or (or x5 x2) (not x5)) (or (and x6 x1) (or x0 x4))) (not (and (and x6 x6) (not x3))))))))) +(assert (or (or x5 x5) (or x0 x3))) +(check-sat) +(push 1) +(assert (not (and (not x6) (not x2)))) +(assert (not (or (and (not (not (or (and (not (and x3 x0)) (not (or x6 x3))) (and (or (or x5 x0) (or x1 x1)) (or (or x4 x4) (or x5 x1)))))) (or (or (or (not (or (or x6 x2) (or x3 x5))) (and (not (not x4)) (not (and x6 x1)))) (and (or (and (and x6 x6) (and x2 x3)) (not (or x3 x3))) (or (or (not x0) (or x3 x2)) (and (not x5) (and x5 x4))))) (and (not (and (or (or x0 x0) (not x6)) (and (not x3) (not x3)))) (not (not (and (and x0 x0) (not x0))))))) (not (or (and (not (not (not (or x1 x1)))) (not (not (and (not x2) (or x6 x2))))) (or (or (and (or (or x2 x6) (or x6 x1)) (and (not x0) (and x4 x0))) (not (not (and x5 x2)))) (and (not (not (or x4 x1))) (or (and (not x4) (or x0 x5)) (or (and x1 x5) (not x5)))))))))) +(assert (and (or (and (and (or (not (and (not (and (and x1 x4) (and x1 x6))) (not (and (not x2) (and x1 x2))))) (not (or (or (or (or x3 x1) (or x5 x4)) (or (or x2 x4) (or x5 x2))) (not (and (or x3 x6) (not x0)))))) (or (or (and (not (or (not x5) (not x5))) (or (or (and x2 x2) (not x5)) (not (or x0 x5)))) (not (and (and (and x1 x3) (not x2)) (and (and x2 x1) (not x0))))) (and (not (or (and (not x2) (or x3 x2)) (and (not x3) (and x2 x5)))) (not (or (and (or x2 x2) (not x4)) (or (not x4) (not x1))))))) (and (and (or (and (not (and (not x0) (and x0 x4))) (and (and (not x6) (or x6 x2)) (or (and x5 x3) (and x5 x1)))) (and (or (and (not x0) (and x1 x4)) (not (or x2 x4))) (not (and (or x2 x5) (and x2 x2))))) (or (and (not (or (and x5 x5) (or x3 x1))) (not (not (not x3)))) (or (not (not (not x1))) (and (or (and x1 x4) (not x0)) (or (and x1 x0) (not x6)))))) (or (and (or (and (or (not x2) (and x4 x0)) (not (or x3 x1))) (or (or (or x0 x6) (or x2 x5)) (or (and x4 x4) (and x3 x2)))) (and (and (and (and x6 x1) (and x2 x3)) (or (not x1) (or x1 x4))) (or (and (or x6 x4) (not x3)) (or (or x1 x1) (and x5 x2))))) (or (or (or (not (not x4)) (and (not x0) (and x6 x6))) (or (and (not x4) (and x5 x2)) (not (not x4)))) (not (and (or (or x0 x3) (and x3 x5)) (not (not x2)))))))) (not (and (and (not (or (and (or (or x4 x3) (not x4)) (or (and x2 x5) (and x0 x3))) (and (and (or x2 x5) (or x1 x0)) (or (or x6 x4) (and x3 x2))))) (or (not (or (or (or x1 x5) (or x5 x3)) (not (not x1)))) (and (and (not (not x4)) (or (not x1) (and x1 x6))) (not (and (not x0) (not x6)))))) (not (or (and (or (and (not x1) (or x2 x4)) (not (or x5 x3))) (not (or (not x1) (not x0)))) (not (or (not (or x5 x1)) (and (or x1 x0) (and x1 x0))))))))) (or (or (and (and (not (not (not (or (or x3 x1) (or x6 x4))))) (or (not (not (and (and x2 x4) (and x0 x5)))) (and (and (and (and x4 x4) (or x5 x5)) (not (not x3))) (or (not (not x5)) (not (and x4 x1)))))) (and (or (and (or (not (and x6 x6)) (or (or x5 x1) (and x1 x2))) (not (not (and x1 x2)))) (and (and (or (and x3 x6) (not x4)) (and (not x5) (or x6 x5))) (not (and (not x5) (or x4 x3))))) (or (not (not (and (not x6) (and x3 x0)))) (or (and (and (and x3 x1) (and x6 x5)) (and (or x2 x5) (not x0))) (and (and (not x1) (not x6)) (not (not x3))))))) (not (and (not (not (not (and (or x6 x3) (not x6))))) (and (not (and (and (and x0 x0) (not x4)) (not (or x6 x1)))) (or (not (or (not x3) (not x5))) (or (or (not x6) (not x5)) (and (or x2 x6) (not x2)))))))) (and (and (not (or (and (not (not (or x5 x3))) (not (not (not x1)))) (not (not (not (and x2 x3)))))) (not (and (or (or (or (not x2) (or x2 x2)) (and (not x3) (or x4 x4))) (not (not (not x0)))) (and (and (and (and x5 x6) (or x1 x5)) (or (or x6 x1) (and x6 x1))) (and (not (or x0 x1)) (and (not x4) (and x5 x0))))))) (not (and (or (not (or (not (and x4 x6)) (or (not x5) (or x5 x0)))) (and (or (and (or x6 x1) (or x6 x1)) (and (not x2) (and x2 x0))) (or (not (and x5 x5)) (not (or x0 x5))))) (not (and (and (and (and x5 x1) (or x5 x2)) (and (and x3 x3) (or x2 x5))) (or (not (not x5)) (not (not x5))))))))))) +(check-sat) +(push 1) +(assert (not (or (and (and (not (or (and (or x4 x2) (or x0 x4)) (and (or x5 x2) (or x0 x5)))) (and (not (or (not x4) (and x4 x5))) (or (or (or x4 x5) (not x5)) (and (not x4) (or x0 x6))))) (or (and (not (not (not x6))) (or (and (not x1) (or x4 x3)) (or (or x5 x2) (or x6 x6)))) (and (not (and (or x4 x6) (not x1))) (or (or (and x2 x4) (and x3 x3)) (and (or x5 x0) (and x4 x2)))))) (not (not (and (not (not (and x1 x3))) (or (and (or x6 x5) (not x5)) (not (or x6 x5))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (not (or x6 x3)) (or (and x5 x4) (and x1 x0)))) +(assert (not (not (not x1)))) +(assert (and (not (not (or (and x3 x5) (and x6 x3)))) (and (and (not (not x4)) (or (or x5 x5) (or x4 x4))) (or (not (not x0)) (and (and x1 x3) (or x4 x6)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (or x2 x3) (or x1 x5))) +(check-sat) +(pop 1) +(assert (and (or (or (or (or (and (or x1 x3) (and x2 x6)) (or (not x1) (not x1))) (or (not (and x6 x2)) (and (not x1) (or x1 x3)))) (and (and (or (and x3 x4) (not x5)) (and (or x6 x4) (and x6 x3))) (and (not (not x2)) (and (not x2) (or x2 x2))))) (and (and (not (not (and x0 x3))) (or (or (or x4 x4) (or x0 x1)) (or (not x3) (and x3 x5)))) (or (and (and (not x0) (and x4 x2)) (not (not x2))) (and (not (or x4 x1)) (not (and x1 x5)))))) (and (not (or (not (or (or x6 x6) (and x0 x4))) (and (and (not x6) (not x0)) (and (or x0 x0) (and x2 x2))))) (and (or (and (or (not x1) (or x3 x0)) (or (and x3 x2) (or x2 x3))) (and (not (not x1)) (and (and x1 x4) (or x2 x2)))) (not (not (and (or x5 x2) (and x3 x5)))))))) +(check-sat) +(pop 1) +(assert (not (and (not (and (and (or (and (not (not (and x0 x2))) (or (or (not x1) (and x6 x5)) (and (and x6 x0) (and x6 x4)))) (and (or (or (and x0 x0) (or x1 x5)) (not (or x5 x2))) (not (or (not x5) (or x1 x3))))) (not (not (not (or (or x4 x1) (or x0 x1)))))) (not (and (and (not (not (or x3 x3))) (or (and (not x3) (or x5 x6)) (and (not x5) (not x4)))) (and (not (not (and x1 x0))) (or (or (not x2) (and x3 x6)) (not (or x1 x0)))))))) (not (and (not (and (or (or (and (or x1 x3) (not x6)) (not (not x0))) (not (and (not x1) (not x5)))) (or (and (not (and x0 x6)) (and (and x6 x6) (and x2 x4))) (or (or (or x5 x5) (or x1 x0)) (or (and x6 x4) (and x0 x3)))))) (not (not (or (not (and (not x3) (not x5))) (not (and (and x6 x4) (and x2 x0))))))))))) +(check-sat) +(pop 1) +(assert (and (and (or (and (or (or (or (not (and (or x1 x0) (or x5 x0))) (and (not (not x2)) (not (or x4 x6)))) (or (not (or (or x4 x2) (not x0))) (not (or (not x1) (and x1 x3))))) (and (and (not (not (or x0 x6))) (or (and (and x5 x4) (not x3)) (not (and x3 x5)))) (not (and (or (or x0 x5) (or x3 x6)) (not (not x5)))))) (not (or (or (and (and (or x0 x5) (and x2 x3)) (not (not x1))) (not (not (and x0 x6)))) (or (and (and (and x4 x4) (not x0)) (not (not x3))) (or (and (not x0) (and x5 x0)) (or (and x6 x3) (not x2))))))) (not (not (not (or (and (or (and x2 x5) (and x2 x2)) (not (and x1 x1))) (and (or (and x5 x1) (or x5 x5)) (and (or x4 x5) (not x0)))))))) (or (not (not (or (or (and (not (or x4 x4)) (and (not x4) (and x0 x3))) (and (and (and x3 x4) (and x6 x1)) (or (not x5) (or x3 x3)))) (or (not (and (or x2 x5) (not x1))) (not (or (and x5 x4) (not x6))))))) (or (or (not (not (or (or (and x4 x4) (not x0)) (not (or x0 x2))))) (and (not (not (and (or x5 x6) (not x4)))) (or (or (not (and x3 x5)) (and (not x0) (and x2 x4))) (and (or (and x0 x4) (or x1 x2)) (or (and x4 x1) (and x5 x3)))))) (not (not (and (and (not (not x5)) (and (and x3 x2) (and x2 x2))) (or (or (and x0 x6) (or x4 x0)) (and (or x2 x3) (and x4 x2))))))))) (or (or (and (or (not (not (or (not (and x1 x6)) (or (or x5 x6) (not x3))))) (and (and (and (and (not x5) (and x5 x3)) (or (or x4 x1) (not x2))) (not (or (and x4 x3) (or x6 x1)))) (not (or (not (not x4)) (or (not x0) (and x2 x2)))))) (not (or (or (and (or (and x3 x4) (not x2)) (and (or x6 x0) (not x4))) (and (not (not x2)) (or (not x0) (or x4 x5)))) (or (not (or (and x5 x3) (not x5))) (not (not (not x4))))))) (not (and (and (not (not (or (not x0) (not x3)))) (not (not (or (not x5) (and x1 x3))))) (and (or (not (and (not x2) (not x0))) (not (and (and x5 x5) (and x4 x3)))) (or (not (and (not x1) (and x5 x0))) (and (and (or x4 x5) (or x5 x3)) (not (not x1)))))))) (and (not (not (or (and (or (not (or x6 x0)) (or (or x3 x2) (not x5))) (not (and (and x1 x4) (not x1)))) (and (or (and (and x2 x3) (or x2 x1)) (not (or x4 x0))) (not (or (not x3) (and x3 x5))))))) (or (or (or (or (not (and (and x5 x1) (or x4 x1))) (not (or (and x3 x1) (or x5 x0)))) (or (not (or (not x2) (and x3 x5))) (or (or (and x3 x5) (and x3 x3)) (not (not x1))))) (not (and (not (not (and x2 x2))) (or (and (not x3) (and x1 x1)) (not (or x3 x4)))))) (or (not (not (or (and (or x2 x2) (not x5)) (or (not x5) (not x2))))) (or (not (and (or (not x3) (and x6 x6)) (not (not x5)))) (or (and (or (and x5 x0) (and x2 x0)) (and (and x0 x2) (not x1))) (and (or (or x5 x6) (and x2 x1)) (or (and x4 x1) (and x1 x0))))))))))) diff --git a/test/regress/regress1/push-pop/fuzz_11.smt2 b/test/regress/regress1/push-pop/fuzz_11.smt2 new file mode 100644 index 000000000..5307ec839 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_11.smt2 @@ -0,0 +1,77 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(assert (not (not (or (or (not (or (not (or (or (not x3) (or x3 x3)) (not (not x3)))) (and (not (and (and x2 x1) (not x3))) (and (or (or x3 x1) (not x5)) (or (not x3) (or x4 x0)))))) (and (not (or (not (and (and x3 x0) (and x4 x5))) (or (not (and x0 x0)) (and (and x5 x4) (not x3))))) (and (and (or (not (and x3 x0)) (or (not x2) (or x5 x1))) (not (and (and x2 x0) (or x5 x4)))) (not (or (not (and x2 x1)) (or (not x4) (and x3 x5))))))) (or (or (and (and (or (not (or x5 x0)) (or (not x2) (not x3))) (not (not (and x1 x1)))) (and (or (or (or x2 x5) (not x1)) (or (or x2 x0) (and x0 x4))) (or (and (and x3 x5) (and x1 x4)) (and (or x5 x0) (and x1 x2))))) (not (or (not (or (and x2 x2) (or x4 x3))) (not (or (or x3 x4) (and x0 x0)))))) (or (not (not (not (and (and x1 x2) (or x5 x0))))) (or (and (or (and (and x0 x5) (and x0 x3)) (or (or x2 x0) (or x3 x3))) (or (and (or x4 x4) (or x0 x5)) (not (not x5)))) (or (not (or (or x4 x1) (and x4 x2))) (and (not (not x5)) (or (or x5 x4) (and x2 x1))))))))))) +(check-sat) +(push 1) +(assert (not (not (not x1)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (or (or (or (and (or (and (and (not (and x1 x4)) (and (not x1) (not x1))) (or (not (or x2 x4)) (or (not x5) (and x2 x4)))) (or (not (and (and x0 x2) (and x2 x3))) (or (and (not x1) (or x4 x3)) (or (not x4) (and x2 x0))))) (not (not (and (or (not x3) (and x5 x0)) (not (and x1 x4)))))) (not (and (not (not (and (or x1 x4) (not x5)))) (not (and (not (and x2 x5)) (not (or x1 x4))))))) (and (and (or (or (and (or (or x1 x4) (not x5)) (and (and x3 x1) (or x4 x2))) (not (or (or x4 x4) (not x4)))) (and (and (or (and x1 x4) (and x3 x0)) (not (not x0))) (not (and (or x2 x3) (not x3))))) (and (and (and (not (not x3)) (and (not x5) (or x1 x3))) (not (and (and x4 x0) (and x5 x3)))) (not (and (and (not x1) (not x3)) (and (or x1 x5) (not x5)))))) (or (and (and (and (not (or x5 x3)) (or (or x3 x2) (not x1))) (not (and (not x3) (or x3 x1)))) (or (or (and (and x5 x5) (not x4)) (and (not x3) (not x1))) (not (or (not x1) (and x3 x2))))) (not (not (not (or (not x0) (or x1 x0)))))))) (not (not (or (not (and (not (and (or x5 x5) (not x2))) (not (not (and x5 x0))))) (or (and (and (and (and x1 x4) (or x0 x4)) (and (or x3 x4) (not x5))) (or (and (and x5 x3) (not x5)) (and (and x5 x3) (not x0)))) (or (not (and (or x5 x2) (and x0 x5))) (or (or (and x4 x4) (and x3 x0)) (and (or x3 x3) (or x0 x3))))))))) (or (not (or (not (and (not (or (and (and x5 x2) (and x5 x4)) (not (and x4 x2)))) (not (not (and (or x3 x5) (not x1)))))) (or (or (not (and (or (not x4) (and x3 x5)) (or (or x4 x0) (not x1)))) (and (or (or (or x1 x1) (and x5 x1)) (not (or x5 x5))) (not (or (or x3 x3) (not x5))))) (and (and (or (and (or x2 x2) (not x2)) (or (and x1 x3) (and x3 x4))) (or (and (and x0 x1) (not x5)) (and (not x3) (and x3 x5)))) (and (or (or (not x0) (not x3)) (not (not x1))) (not (not (not x4)))))))) (not (not (and (not (not (or (or (not x1) (or x2 x0)) (or (and x5 x4) (or x3 x4))))) (and (and (and (and (and x5 x3) (or x1 x4)) (or (or x1 x5) (not x3))) (not (not (not x0)))) (not (or (or (not x3) (and x5 x1)) (not (and x5 x4))))))))))) +(assert (not (and (and (and (not (or (not x3) (and x0 x2))) (and (not (not x5)) (not (not x1)))) (not (or (or (or x5 x1) (not x5)) (not (not x3))))) (and (not (and (or (or x2 x2) (and x5 x5)) (not (not x5)))) (not (not (not (and x4 x2)))))))) +(assert (not (or (not (not (and (and (not (and (and x3 x5) (or x4 x3))) (and (and (or x0 x1) (and x3 x1)) (and (not x0) (and x4 x3)))) (and (and (not (or x0 x4)) (or (not x3) (not x1))) (or (or (or x4 x5) (and x3 x4)) (or (and x5 x2) (and x4 x0))))))) (not (or (not (or (and (or (or x3 x4) (or x5 x2)) (not (or x1 x0))) (or (not (not x0)) (not (and x1 x4))))) (not (not (or (and (and x0 x2) (or x1 x1)) (not (not x5)))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (and (or (or (or (not x0) (or x1 x4)) (not (not x4))) (and (and (or x0 x1) (not x1)) (or (and x4 x5) (and x4 x5)))) (or (and (and (or x3 x3) (or x4 x0)) (or (and x1 x2) (and x3 x2))) (or (not (or x0 x0)) (not (and x5 x0))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (or (or x5 x1) (or x3 x0)) (and (and x2 x3) (or x3 x5))) (or (and (not x3) (or x0 x3)) (and (not x3) (or x4 x0))))) +(assert (not (and (and (not x2) (or x0 x5)) (and (not x1) (or x3 x1))))) +(assert (not (or (or x3 x4) (or x5 x5)))) +(assert (and (not (and (and (or (or (or (not (or x3 x3)) (and (not x4) (or x1 x0))) (and (or (not x4) (or x0 x5)) (and (not x2) (and x2 x3)))) (and (or (or (not x2) (and x4 x3)) (and (not x0) (not x0))) (or (and (and x1 x4) (not x1)) (and (and x2 x2) (or x4 x5))))) (and (not (and (and (and x5 x5) (and x5 x1)) (or (not x4) (not x0)))) (or (not (or (not x1) (not x1))) (or (and (not x0) (and x2 x4)) (or (and x5 x3) (and x2 x2)))))) (and (not (and (or (and (and x3 x5) (or x3 x3)) (or (and x5 x1) (and x4 x5))) (not (and (or x5 x1) (not x5))))) (or (and (or (not (or x5 x0)) (or (or x1 x2) (not x4))) (not (not (not x0)))) (not (and (or (and x2 x2) (and x2 x1)) (not (and x2 x1)))))))) (not (or (not (not (not (and (not (or x1 x3)) (and (and x5 x0) (or x4 x5)))))) (or (and (and (or (or (and x5 x4) (and x4 x3)) (or (and x2 x2) (and x3 x2))) (not (and (and x5 x0) (not x4)))) (and (and (not (and x3 x2)) (and (not x1) (not x5))) (or (or (and x1 x4) (not x2)) (not (or x5 x2))))) (or (and (not (and (and x5 x4) (or x1 x3))) (or (and (and x0 x0) (or x3 x5)) (not (not x2)))) (not (and (and (not x2) (and x1 x0)) (and (and x3 x0) (and x5 x5)))))))))) +(assert (or (not (and (and (or (or (and (and (or (not x4) (not x0)) (or (or x2 x0) (not x2))) (not (and (not x3) (and x3 x3)))) (not (or (and (or x1 x4) (and x3 x2)) (and (or x4 x3) (and x4 x5))))) (not (and (or (or (or x3 x5) (or x5 x4)) (or (or x5 x1) (not x0))) (and (or (or x1 x5) (and x4 x1)) (and (or x3 x5) (not x5)))))) (and (and (or (and (and (not x3) (and x3 x2)) (or (or x3 x3) (and x5 x3))) (and (or (not x2) (not x4)) (and (and x2 x2) (and x1 x5)))) (and (not (and (not x5) (and x4 x2))) (not (not (and x0 x0))))) (not (and (not (not (and x0 x2))) (and (or (not x3) (not x3)) (not (not x5))))))) (not (and (and (not (and (or (and x2 x3) (or x2 x0)) (or (or x0 x3) (and x4 x4)))) (or (and (and (not x5) (and x0 x2)) (not (or x1 x2))) (not (and (or x3 x5) (not x4))))) (not (or (or (and (or x4 x4) (not x5)) (or (or x3 x4) (not x0))) (and (not (and x1 x4)) (and (not x4) (and x5 x2))))))))) (and (not (not (and (and (and (not (not (not x0))) (or (not (or x4 x5)) (or (and x1 x5) (not x2)))) (not (and (and (and x3 x4) (not x1)) (and (not x3) (and x1 x5))))) (or (not (and (or (not x2) (and x1 x5)) (not (and x3 x2)))) (or (and (and (or x1 x3) (or x5 x0)) (not (or x1 x3))) (not (not (not x4)))))))) (not (not (and (not (or (and (and (not x3) (not x2)) (not (or x4 x2))) (and (and (or x5 x1) (or x3 x5)) (not (and x4 x3))))) (or (or (not (not (or x3 x1))) (not (or (or x4 x0) (and x0 x3)))) (or (not (not (or x0 x3))) (or (and (not x2) (not x1)) (and (or x5 x0) (and x4 x5))))))))))) +(check-sat) +(push 1) +(assert (or (and (and (not (not (not (and (or (or x3 x0) (or x3 x1)) (not (not x2)))))) (not (not (or (and (or (and x4 x0) (not x4)) (not (or x4 x1))) (and (or (not x1) (or x3 x2)) (or (or x5 x1) (not x1))))))) (and (not (and (or (not (and (or x3 x1) (not x2))) (and (and (and x4 x5) (not x5)) (and (and x0 x0) (and x1 x2)))) (not (not (or (not x2) (and x3 x1)))))) (not (or (or (or (and (not x0) (and x4 x5)) (or (not x2) (and x2 x1))) (not (or (not x0) (not x0)))) (and (not (and (and x2 x0) (not x5))) (or (and (or x4 x0) (not x0)) (or (and x4 x3) (or x4 x5)))))))) (and (and (not (and (and (and (not (and x3 x0)) (and (not x1) (or x5 x1))) (or (not (not x1)) (not (or x0 x2)))) (and (or (not (not x0)) (or (and x4 x4) (and x2 x4))) (or (not (not x4)) (not (and x3 x4)))))) (not (or (not (not (and (or x0 x0) (or x4 x0)))) (not (and (not (not x4)) (or (and x0 x5) (or x3 x3))))))) (and (not (not (not (or (and (or x2 x3) (and x2 x2)) (not (or x0 x3)))))) (or (or (and (or (and (or x2 x4) (and x1 x4)) (and (and x5 x1) (not x0))) (not (not (or x0 x3)))) (not (and (and (not x4) (not x2)) (or (not x1) (or x3 x4))))) (not (and (not (or (or x4 x2) (and x2 x5))) (or (not (not x5)) (not (not x3)))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (and (not x3) (not x3)) (and (and x2 x3) (or x4 x1)))) +(assert (not (and (or (or (and (or (or (or (or x4 x0) (and x3 x0)) (or (or x3 x4) (not x4))) (or (or (and x2 x4) (and x4 x2)) (not (or x4 x0)))) (or (and (or (and x2 x4) (or x1 x0)) (and (not x1) (and x0 x5))) (or (and (not x4) (not x3)) (not (not x1))))) (not (or (and (and (or x3 x1) (or x2 x3)) (or (not x5) (and x4 x5))) (not (and (or x5 x2) (not x5)))))) (or (or (or (or (or (and x0 x5) (or x1 x4)) (not (and x1 x2))) (or (or (not x1) (or x4 x5)) (and (and x5 x0) (not x4)))) (or (or (or (or x0 x5) (and x0 x0)) (and (or x1 x2) (not x3))) (not (or (or x3 x1) (or x4 x0))))) (not (and (not (or (or x0 x3) (not x0))) (or (or (and x0 x5) (or x4 x3)) (or (and x4 x0) (or x0 x2))))))) (and (and (or (or (not (and (and x4 x0) (and x2 x1))) (and (or (and x3 x3) (and x2 x1)) (not (not x5)))) (not (not (and (not x3) (not x0))))) (or (and (and (and (and x3 x0) (or x2 x1)) (not (not x0))) (and (not (not x4)) (or (and x0 x1) (or x3 x4)))) (and (or (or (and x4 x2) (and x2 x0)) (or (and x5 x1) (not x0))) (and (and (not x1) (and x5 x0)) (or (or x0 x3) (and x5 x3)))))) (not (or (and (not (and (or x5 x3) (and x5 x1))) (or (or (and x2 x3) (or x3 x2)) (or (and x0 x5) (not x5)))) (or (or (not (not x5)) (or (and x0 x3) (and x5 x0))) (or (not (or x2 x1)) (or (or x3 x5) (and x0 x0)))))))))) +(check-sat) +(pop 1) +(assert (or (and (and (and (not x1) (or x5 x5)) (and (or x2 x1) (not x0))) (and (not (or x1 x3)) (and (not x0) (or x3 x5)))) (or (or (and (or x0 x2) (not x1)) (and (and x3 x2) (or x0 x5))) (and (or (or x0 x0) (and x2 x5)) (or (or x0 x3) (not x1)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (not (and (or (not (not (or (not (not x5)) (and (not x5) (not x1))))) (and (not (or (or (or x0 x0) (not x5)) (not (or x5 x2)))) (or (or (not (or x3 x2)) (or (not x2) (or x5 x5))) (or (and (not x2) (and x0 x2)) (and (and x5 x5) (or x3 x4)))))) (not (not (or (not (not (and x2 x2))) (and (and (not x2) (or x5 x0)) (or (not x4) (and x5 x4)))))))) (or (and (and (not (not (or (and (or x0 x0) (or x4 x1)) (or (and x5 x4) (or x1 x2))))) (and (and (not (and (and x0 x0) (or x5 x3))) (or (or (and x4 x3) (not x2)) (and (not x0) (not x3)))) (and (or (and (not x3) (not x1)) (not (not x0))) (or (and (and x4 x1) (not x0)) (and (not x0) (not x5)))))) (not (not (and (not (and (and x3 x3) (or x5 x5))) (and (or (not x4) (and x4 x3)) (and (and x4 x3) (or x4 x5))))))) (and (or (not (not (not (and (not x3) (or x4 x4))))) (or (not (not (or (not x2) (and x5 x4)))) (or (and (or (and x3 x5) (or x0 x1)) (and (not x2) (not x1))) (not (or (or x2 x0) (and x0 x2)))))) (and (and (not (and (or (not x3) (or x4 x1)) (and (or x2 x1) (not x0)))) (and (and (not (or x2 x2)) (not (not x3))) (or (and (and x2 x2) (or x4 x0)) (or (or x1 x2) (and x1 x5))))) (or (not (not (not (or x2 x3)))) (not (not (or (not x4) (or x3 x0)))))))))) +(check-sat) +(push 1) +(assert (and (or (not (not (not (or (not x0) (and x3 x1))))) (or (not (not (or (not x2) (and x2 x3)))) (or (and (or (and x0 x3) (not x4)) (or (not x0) (not x1))) (or (and (or x4 x5) (and x0 x2)) (not (and x2 x5)))))) (not (not (not (and (and (not x1) (and x1 x0)) (not (and x2 x4)))))))) +(assert (not x0)) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_15.smt2 b/test/regress/regress1/push-pop/fuzz_15.smt2 new file mode 100644 index 000000000..4345c3231 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_15.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (or (or (or (or (or (or (and (not x3) (or x0 x1)) (and (and x3 x2) (not x7))) (and (not (or x3 x2)) (and (not x5) (or x1 x6)))) (and (and (or (and x4 x2) (or x4 x1)) (not (not x3))) (and (and (and x6 x5) (or x7 x4)) (not (or x3 x7))))) (or (or (or (or (and x3 x2) (or x6 x6)) (and (or x0 x2) (or x1 x0))) (or (or (or x1 x5) (and x6 x7)) (and (not x3) (not x5)))) (and (or (not (not x5)) (and (and x0 x2) (and x6 x4))) (not (or (or x0 x7) (not x0)))))) (and (or (and (not (not (not x0))) (or (and (or x1 x6) (not x2)) (not (and x7 x3)))) (and (not (not (not x5))) (not (and (or x0 x1) (not x0))))) (not (or (and (and (and x1 x1) (not x0)) (not (and x1 x0))) (or (not (not x5)) (and (or x7 x2) (not x7))))))) (and (or (not (and (and (and (or x6 x3) (not x4)) (and (or x5 x7) (or x6 x2))) (and (or (and x0 x3) (and x6 x6)) (and (and x0 x3) (not x0))))) (or (not (and (not (or x2 x6)) (or (and x2 x1) (and x0 x0)))) (or (and (not (and x5 x5)) (not (and x4 x4))) (and (not (or x7 x5)) (or (not x6) (or x3 x6)))))) (and (and (not (and (not (not x7)) (not (and x0 x6)))) (or (and (and (and x7 x1) (or x3 x5)) (not (or x7 x0))) (not (or (or x2 x1) (not x0))))) (or (or (not (not (or x2 x3))) (not (and (or x3 x5) (and x7 x7)))) (not (and (and (or x6 x3) (and x5 x3)) (and (not x2) (and x4 x5))))))))) (and (or (not (or (or (or (not (and (or x3 x2) (or x1 x0))) (and (not (or x6 x2)) (or (and x5 x4) (or x0 x6)))) (and (and (or (and x0 x6) (and x7 x6)) (and (not x0) (or x0 x4))) (and (or (and x7 x5) (or x4 x4)) (not (and x0 x5))))) (and (and (and (or (or x1 x6) (and x1 x4)) (not (and x2 x4))) (or (not (and x6 x6)) (and (not x3) (or x3 x1)))) (and (and (not (or x7 x6)) (not (not x4))) (or (not (not x7)) (or (not x3) (or x7 x5))))))) (not (not (and (or (and (and (and x0 x1) (or x3 x2)) (and (not x3) (not x2))) (not (not (or x6 x6)))) (or (or (and (and x3 x0) (not x2)) (or (and x7 x4) (not x2))) (not (and (not x4) (and x6 x6)))))))) (or (and (not (or (not (and (not (or x2 x4)) (and (and x1 x2) (and x1 x7)))) (not (not (and (and x2 x5) (or x5 x1)))))) (or (or (and (and (and (and x0 x1) (and x3 x5)) (and (and x0 x5) (not x6))) (or (or (or x7 x4) (not x5)) (and (and x0 x7) (and x5 x0)))) (and (not (not (and x5 x4))) (and (and (or x2 x4) (not x4)) (not (or x7 x3))))) (or (not (and (and (not x7) (not x3)) (not (or x2 x4)))) (and (not (or (and x4 x0) (not x1))) (and (and (not x1) (not x2)) (or (or x1 x4) (and x7 x1))))))) (or (and (and (or (and (or (or x1 x0) (and x0 x2)) (or (or x7 x5) (or x0 x4))) (and (or (and x1 x3) (and x4 x5)) (and (or x4 x0) (or x0 x3)))) (and (and (or (not x7) (and x4 x0)) (not (and x6 x3))) (and (and (and x3 x2) (not x1)) (not (and x3 x0))))) (not (not (not (and (not x6) (not x6)))))) (or (not (and (or (or (not x0) (and x5 x1)) (not (and x0 x3))) (or (not (and x7 x5)) (and (and x0 x1) (and x3 x3))))) (and (and (and (and (or x3 x3) (and x6 x2)) (not (not x0))) (or (and (not x4) (and x0 x7)) (and (not x7) (not x7)))) (or (not (not (not x5))) (not (and (not x5) (or x7 x0))))))))))) +(check-sat) +(push 1) +(assert (and (or (or (not (not (not x1))) (and (not (not x2)) (not (and x3 x2)))) (not (not (or (not x2) (and x5 x5))))) (and (not (and (or (or x1 x1) (not x3)) (and (or x0 x3) (not x2)))) (or (not (or (or x2 x3) (or x4 x1))) (or (and (not x6) (not x5)) (not (or x4 x1))))))) +(assert (and (not (not (and (not (or x5 x6)) (or (and x7 x0) (not x2))))) (or (not (not (and (not x5) (not x7)))) (or (and (and (not x3) (or x0 x6)) (or (and x2 x7) (or x5 x0))) (and (and (or x4 x3) (or x7 x6)) (not (and x7 x4))))))) +(assert (not x2)) +(assert (or (not (and (and (not (or (and (not (and (and x1 x6) (not x6))) (and (not (or x5 x5)) (not (and x2 x6)))) (and (and (not (not x0)) (and (and x5 x2) (or x5 x1))) (or (not (and x6 x3)) (not (or x1 x4)))))) (and (not (not (not (and (or x3 x4) (and x2 x7))))) (or (not (and (not (not x3)) (or (not x0) (not x2)))) (and (not (not (and x4 x1))) (and (or (not x2) (and x3 x3)) (not (or x7 x6))))))) (not (or (or (and (not (or (and x3 x6) (not x4))) (not (not (or x4 x2)))) (not (or (not (not x3)) (not (not x5))))) (or (not (not (not (or x7 x5)))) (or (or (or (and x5 x5) (and x0 x4)) (or (and x3 x2) (not x7))) (or (and (or x2 x6) (or x6 x0)) (and (and x6 x7) (and x3 x6))))))))) (and (and (or (and (or (and (not (and (or x2 x4) (not x5))) (and (and (and x3 x6) (and x6 x4)) (or (or x4 x2) (and x3 x1)))) (or (or (and (and x3 x7) (or x2 x3)) (or (or x7 x6) (or x1 x3))) (not (not (not x4))))) (or (and (or (or (and x6 x5) (and x5 x0)) (not (or x6 x1))) (not (and (or x0 x4) (or x4 x1)))) (not (not (or (or x5 x4) (not x4)))))) (and (or (or (not (or (not x2) (or x3 x7))) (or (or (not x3) (not x5)) (or (or x5 x1) (and x1 x2)))) (and (and (and (and x0 x2) (or x4 x3)) (or (and x7 x2) (or x1 x6))) (and (and (and x4 x3) (or x2 x1)) (or (not x6) (and x3 x0))))) (and (not (or (or (or x4 x7) (and x0 x2)) (or (and x1 x1) (and x2 x7)))) (not (and (or (not x6) (and x6 x7)) (not (not x5))))))) (or (or (not (or (or (or (or x3 x5) (or x0 x5)) (not (or x0 x5))) (or (or (and x7 x7) (or x2 x3)) (or (or x1 x7) (or x1 x5))))) (or (not (and (or (and x3 x6) (not x0)) (or (not x6) (not x0)))) (not (and (and (or x1 x0) (and x3 x2)) (not (and x4 x1)))))) (not (not (or (and (or (or x3 x3) (and x6 x1)) (and (or x1 x6) (and x4 x7))) (and (and (and x0 x6) (or x5 x2)) (not (and x6 x6)))))))) (or (or (not (or (not (not (and (or x4 x0) (and x5 x5)))) (and (and (and (or x3 x3) (and x0 x2)) (or (not x2) (not x1))) (or (or (not x1) (and x0 x2)) (not (not x2)))))) (and (or (or (not (not (not x4))) (and (or (not x5) (or x3 x7)) (and (or x2 x5) (and x2 x6)))) (not (not (not (or x1 x5))))) (and (not (not (not (and x7 x0)))) (and (not (not (not x0))) (or (or (and x4 x0) (not x2)) (or (and x7 x6) (not x5))))))) (not (and (or (not (not (not (and x4 x7)))) (or (not (not (or x5 x1))) (or (or (and x2 x6) (or x6 x7)) (or (not x5) (not x7))))) (not (not (not (and (not x6) (and x5 x5))))))))))) +(check-sat) +(pop 1) +(assert (not (not (not x3)))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_16.smt2 b/test/regress/regress1/push-pop/fuzz_16.smt2 new file mode 100644 index 000000000..715b1872c --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_16.smt2 @@ -0,0 +1,47 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(assert (or (or (and (not (not (not x0))) (not (and (not x4) (not x1)))) (and (and (or (and x3 x1) (not x1)) (and (not x3) (and x3 x4))) (and (or (or x1 x4) (and x3 x2)) (and (and x2 x4) (or x1 x4))))) (not (or (or (and (and x4 x1) (or x4 x2)) (and (or x0 x3) (not x2))) (not (or (or x0 x0) (and x0 x2))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (not (or (and (not (or (or (and (or (or x2 x0) (not x4)) (not (not x2))) (and (not (not x0)) (not (and x2 x1)))) (and (or (or (and x2 x2) (or x0 x4)) (or (and x0 x2) (or x3 x2))) (or (and (and x1 x3) (and x0 x4)) (or (or x0 x4) (and x4 x0)))))) (or (or (or (and (not (not x1)) (and (or x0 x3) (and x2 x4))) (and (not (and x2 x1)) (and (not x0) (and x1 x3)))) (and (not (and (or x3 x4) (and x4 x3))) (or (or (not x4) (not x2)) (and (not x1) (or x0 x3))))) (or (or (not (and (not x2) (and x4 x0))) (or (and (not x3) (and x2 x2)) (or (and x0 x2) (and x1 x3)))) (and (or (and (and x1 x4) (or x4 x4)) (not (not x0))) (not (not (not x0))))))) (and (not (and (or (not (and (not x2) (not x2))) (or (not (or x3 x4)) (not (or x4 x1)))) (not (and (not (not x4)) (and (and x4 x3) (and x0 x1)))))) (not (or (and (and (not (not x0)) (not (or x2 x1))) (not (and (or x1 x2) (or x0 x3)))) (or (or (or (not x1) (not x3)) (not (and x1 x2))) (and (or (and x2 x4) (or x3 x4)) (and (or x2 x0) (not x1)))))))))) +(assert (not (or (not (or (not (and (or (and (not (or x2 x1)) (and (and x3 x3) (and x0 x1))) (or (or (or x1 x4) (or x0 x0)) (not (and x4 x2)))) (and (not (or (and x0 x1) (not x4))) (and (and (not x2) (or x3 x1)) (and (or x3 x3) (and x0 x4)))))) (or (not (not (not (and (not x0) (not x4))))) (and (not (and (or (and x4 x0) (or x0 x2)) (or (not x0) (and x1 x2)))) (not (and (not (and x1 x1)) (not (and x1 x4)))))))) (not (and (and (not (and (not (or (not x0) (and x1 x2))) (not (not (and x1 x1))))) (or (and (not (not (and x3 x0))) (not (and (and x2 x2) (or x1 x0)))) (and (and (or (not x1) (or x2 x3)) (not (or x2 x1))) (or (not (and x0 x2)) (or (or x3 x1) (and x0 x4)))))) (or (and (or (and (not (or x2 x3)) (not (not x1))) (and (and (and x0 x1) (not x4)) (or (or x3 x1) (or x0 x1)))) (and (or (and (and x0 x0) (and x0 x4)) (or (or x4 x0) (and x2 x2))) (or (and (and x0 x3) (and x1 x3)) (not (and x1 x1))))) (not (and (not (not (not x1))) (or (not (not x4)) (or (and x3 x2) (and x0 x3))))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (or (or (and x1 x2) (and x1 x2)) (and (or x3 x4) (and x1 x3))) (and (and (not x1) (or x4 x1)) (or (or x2 x2) (not x4))))) +(assert (or (or (or (or (not (and (not (and (not (or x2 x0)) (not (or x1 x3)))) (not (not (and (or x4 x0) (not x1)))))) (not (not (or (not (or (not x3) (not x2))) (and (not (or x2 x1)) (and (not x2) (or x2 x2))))))) (not (not (and (and (or (or (not x0) (not x1)) (or (or x4 x3) (or x4 x2))) (and (or (and x0 x2) (and x4 x3)) (or (or x2 x4) (and x1 x4)))) (and (or (not (not x4)) (and (and x4 x4) (not x0))) (and (and (or x0 x2) (and x1 x1)) (and (and x2 x3) (or x2 x3)))))))) (or (and (and (and (or (not (not (not x4))) (or (and (not x4) (and x4 x4)) (or (and x2 x3) (and x4 x4)))) (or (or (and (or x0 x2) (or x3 x4)) (or (not x0) (or x1 x1))) (not (and (and x0 x1) (not x3))))) (and (not (not (and (not x0) (or x3 x4)))) (and (or (or (and x1 x3) (not x1)) (and (or x0 x0) (or x3 x1))) (or (and (or x2 x1) (not x2)) (not (not x3)))))) (or (or (not (or (or (and x3 x1) (and x4 x4)) (not (and x1 x1)))) (and (or (and (and x1 x0) (not x3)) (not (not x4))) (or (or (not x3) (and x2 x1)) (and (not x2) (not x3))))) (not (or (not (or (or x2 x1) (and x4 x4))) (or (and (and x2 x3) (and x1 x4)) (not (or x0 x2))))))) (and (and (not (and (not (and (or x0 x0) (or x4 x0))) (or (or (not x1) (or x2 x2)) (or (and x0 x2) (or x0 x4))))) (not (not (not (and (not x4) (not x4)))))) (or (and (and (and (and (and x4 x0) (not x3)) (not (not x1))) (not (not (and x2 x4)))) (or (not (not (and x3 x0))) (not (and (not x3) (not x3))))) (and (or (and (not (not x4)) (or (or x1 x0) (and x0 x1))) (and (not (or x0 x1)) (and (and x2 x4) (or x1 x4)))) (or (and (not (not x1)) (not (or x1 x1))) (not (and (not x3) (or x0 x3))))))))) (not (and (not (or (or (or (not (and (or x2 x2) (and x2 x3))) (not (and (or x1 x4) (and x1 x1)))) (and (and (and (or x1 x2) (and x1 x2)) (or (and x4 x2) (or x4 x3))) (and (not (not x3)) (not (or x3 x0))))) (not (not (and (or (and x4 x4) (not x3)) (and (or x1 x1) (not x2))))))) (or (not (not (not (not (or (not x4) (and x0 x2)))))) (or (not (or (not (and (or x1 x0) (and x2 x0))) (and (and (not x3) (or x2 x4)) (not (not x0))))) (or (not (and (not (not x3)) (not (and x0 x4)))) (and (or (or (and x4 x1) (and x4 x2)) (or (or x0 x3) (or x3 x2))) (or (or (not x2) (or x2 x4)) (not (not x2))))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (or (and (or (and (or (not (or (and (or x1 x4) (and x4 x1)) (and (not x2) (not x3)))) (and (and (not (or x4 x1)) (or (not x3) (and x2 x3))) (and (or (and x3 x3) (and x0 x2)) (or (and x1 x0) (or x2 x4))))) (not (not (or (or (or x2 x2) (and x3 x3)) (not (not x2)))))) (and (and (or (or (not (not x3)) (or (and x0 x0) (and x1 x1))) (or (and (and x3 x2) (and x0 x1)) (and (and x1 x2) (or x1 x4)))) (not (or (or (and x2 x2) (and x3 x2)) (and (not x2) (not x1))))) (and (not (and (or (and x1 x2) (not x1)) (and (and x1 x1) (or x4 x3)))) (and (or (not (and x3 x3)) (not (not x3))) (or (and (and x0 x4) (not x1)) (or (and x1 x3) (not x0))))))) (not (and (and (or (not (not (or x2 x4))) (not (or (not x3) (and x4 x2)))) (or (or (and (or x2 x0) (and x0 x4)) (not (or x2 x4))) (or (or (or x3 x4) (not x4)) (and (or x3 x1) (or x1 x1))))) (and (and (or (not (or x0 x2)) (or (not x0) (and x3 x4))) (and (not (not x1)) (not (or x1 x0)))) (not (not (or (not x4) (not x0)))))))) (or (not (not (or (and (or (or (and x1 x4) (not x0)) (not (not x0))) (and (and (or x3 x1) (or x0 x4)) (or (and x0 x1) (and x2 x3)))) (not (not (and (not x3) (or x4 x3))))))) (not (and (or (not (and (not (and x0 x3)) (not (not x3)))) (and (or (and (or x0 x1) (and x1 x4)) (not (and x2 x4))) (or (and (not x4) (and x4 x2)) (or (or x2 x1) (not x2))))) (and (or (and (or (not x3) (and x4 x1)) (not (not x0))) (and (and (and x1 x4) (and x2 x1)) (and (not x3) (and x0 x2)))) (not (not (or (not x3) (and x4 x0))))))))) (and (or (or (not (not (and (and (not (or x3 x3)) (or (not x2) (not x0))) (and (or (and x4 x4) (and x3 x3)) (not (and x0 x1)))))) (or (not (or (and (and (and x4 x1) (not x2)) (or (and x2 x4) (not x4))) (and (and (not x1) (not x2)) (or (or x4 x0) (not x4))))) (or (and (or (or (not x4) (not x3)) (not (not x4))) (or (and (or x2 x3) (and x2 x4)) (or (not x1) (and x1 x3)))) (not (and (and (or x2 x3) (and x3 x1)) (not (and x0 x3))))))) (not (and (not (and (and (or (not x0) (or x0 x4)) (not (and x3 x0))) (not (or (and x2 x3) (not x3))))) (and (not (not (or (not x3) (and x2 x1)))) (or (not (not (not x2))) (or (and (and x2 x2) (or x1 x1)) (and (and x2 x4) (not x2)))))))) (or (not (and (not (and (or (or (and x1 x1) (not x4)) (and (not x4) (and x2 x3))) (not (or (not x4) (and x1 x2))))) (or (not (and (and (and x4 x2) (and x1 x0)) (or (and x3 x3) (not x0)))) (not (or (and (and x1 x2) (not x1)) (or (and x1 x1) (not x0))))))) (and (not (or (or (and (not (not x1)) (and (or x1 x1) (not x0))) (and (not (and x2 x2)) (or (or x1 x2) (not x2)))) (or (or (or (and x4 x3) (not x3)) (and (and x2 x3) (or x4 x2))) (not (not (or x2 x0)))))) (not (and (or (or (or (not x0) (not x0)) (or (or x4 x0) (and x4 x1))) (not (not (not x0)))) (or (and (or (and x3 x1) (or x4 x0)) (not (and x1 x1))) (not (and (and x2 x3) (and x4 x3))))))))))) +(assert (or (not (not (and (not (not (or (and (or (and x3 x4) (not x4)) (or (and x2 x2) (not x0))) (or (not (or x3 x4)) (or (and x4 x1) (or x0 x2)))))) (and (not (and (or (not (not x0)) (not (or x3 x1))) (not (and (or x4 x2) (or x4 x2))))) (and (and (or (and (or x1 x2) (not x2)) (or (not x1) (and x1 x2))) (not (and (and x2 x1) (or x1 x4)))) (or (or (or (not x3) (or x4 x0)) (or (not x0) (and x3 x3))) (not (or (and x0 x1) (or x4 x0))))))))) (or (and (and (not (or (and (not (not (and x1 x2))) (and (not (not x3)) (and (and x4 x0) (or x4 x3)))) (or (and (or (or x3 x4) (and x2 x4)) (and (and x2 x2) (or x0 x2))) (not (and (and x0 x1) (and x2 x1)))))) (or (and (not (not (not (not x2)))) (and (and (or (not x2) (and x4 x2)) (and (and x2 x3) (or x0 x4))) (and (or (or x0 x2) (not x0)) (not (and x2 x2))))) (or (and (and (or (or x3 x0) (and x2 x3)) (or (not x2) (and x3 x1))) (or (not (and x2 x0)) (and (not x2) (not x1)))) (not (and (or (and x0 x0) (or x2 x1)) (and (not x4) (or x2 x4))))))) (or (or (or (not (not (and (not x4) (or x1 x1)))) (not (not (not (and x3 x3))))) (or (not (and (and (and x4 x1) (not x4)) (not (not x0)))) (or (or (not (and x4 x1)) (and (not x1) (or x0 x4))) (not (not (and x4 x2)))))) (or (not (not (or (or (or x2 x2) (and x2 x3)) (or (and x3 x4) (not x0))))) (or (not (and (and (not x0) (or x1 x4)) (not (not x3)))) (and (or (and (or x1 x0) (not x1)) (not (or x4 x2))) (or (not (and x0 x1)) (or (and x0 x0) (or x3 x1)))))))) (not (or (and (and (or (or (not (not x4)) (and (or x0 x1) (or x4 x3))) (and (or (not x4) (and x4 x4)) (not (and x2 x0)))) (not (or (not (or x4 x2)) (and (not x1) (or x0 x4))))) (or (or (and (or (not x1) (and x3 x0)) (or (not x1) (and x0 x1))) (or (not (not x4)) (and (and x4 x3) (and x1 x4)))) (or (not (not (or x2 x0))) (and (and (and x4 x2) (not x0)) (and (or x1 x1) (and x2 x4)))))) (or (or (not (not (not (or x2 x4)))) (not (not (or (or x3 x3) (and x1 x1))))) (or (or (and (and (and x2 x4) (and x3 x3)) (and (and x0 x4) (not x1))) (not (not (not x3)))) (and (or (or (and x1 x0) (and x1 x4)) (and (and x4 x0) (or x0 x3))) (or (and (or x1 x0) (and x1 x2)) (not (not x3))))))))))) +(check-sat) +(push 1) +(assert (or (or (and (and (and (and (or (or (not (and x4 x4)) (and (and x4 x0) (not x3))) (and (not (or x4 x0)) (not (or x0 x0)))) (not (or (not (and x3 x0)) (or (and x4 x0) (and x1 x3))))) (or (not (not (not (or x4 x1)))) (not (not (not (not x3)))))) (not (not (not (or (and (not x3) (or x1 x3)) (and (and x2 x3) (or x2 x2))))))) (not (not (or (not (and (not (or x4 x1)) (and (and x1 x4) (and x2 x2)))) (and (not (not (or x3 x2))) (not (not (not x4)))))))) (or (or (and (or (not (not (not (or x1 x1)))) (not (not (not (or x0 x1))))) (not (not (and (not (not x3)) (and (not x2) (and x4 x3)))))) (and (not (or (and (not (and x1 x0)) (and (and x3 x1) (or x1 x0))) (or (not (and x3 x2)) (or (or x1 x4) (and x2 x1))))) (not (not (or (and (and x2 x0) (not x0)) (and (and x2 x0) (and x0 x4))))))) (and (and (not (and (and (or (or x2 x4) (and x0 x3)) (not (or x1 x2))) (not (and (and x1 x1) (or x4 x3))))) (and (not (or (not (or x2 x3)) (or (or x2 x0) (and x3 x4)))) (not (not (or (and x2 x0) (not x4)))))) (or (not (and (not (not (or x0 x0))) (not (not (or x1 x3))))) (and (not (and (and (and x3 x4) (or x1 x0)) (or (and x2 x4) (not x2)))) (not (not (and (and x0 x1) (and x2 x4))))))))) (not (and (or (not (and (and (and (not (or x4 x2)) (and (not x0) (not x0))) (not (or (or x0 x1) (not x2)))) (or (or (and (and x3 x1) (or x4 x3)) (not (and x0 x2))) (or (and (and x1 x0) (not x0)) (or (not x2) (and x3 x3)))))) (not (and (and (and (or (and x3 x4) (and x3 x3)) (not (or x3 x4))) (not (not (and x3 x0)))) (or (and (not (or x4 x4)) (not (not x3))) (and (not (and x4 x1)) (or (and x2 x3) (and x0 x1))))))) (or (and (and (not (or (or (not x3) (not x4)) (not (or x1 x0)))) (and (or (or (and x1 x3) (and x1 x4)) (not (or x3 x1))) (and (not (and x0 x3)) (not (or x1 x1))))) (not (or (not (and (or x0 x0) (and x2 x2))) (not (or (not x4) (not x4)))))) (or (or (and (and (and (and x1 x2) (or x1 x0)) (or (or x1 x2) (or x2 x2))) (not (and (not x0) (or x1 x3)))) (not (or (or (or x0 x1) (or x4 x1)) (not (not x1))))) (not (or (not (and (not x3) (not x3))) (and (or (and x0 x0) (or x0 x1)) (or (and x1 x1) (not x4))))))))))) +(assert (or (and (not (not (or (not (and x1 x3)) (not (not x3))))) (not (not (or (and (or x4 x0) (not x0)) (and (and x0 x0) (and x4 x1)))))) (not (and (and (not (and (or x2 x0) (or x0 x2))) (or (not (not x3)) (and (and x2 x1) (and x1 x3)))) (not (and (not (or x4 x0)) (or (not x2) (not x1)))))))) +(assert (or (and (not (not (and (and (and (not x0) (and x2 x3)) (or (or x1 x0) (and x4 x2))) (or (and (or x1 x0) (and x2 x4)) (or (and x0 x3) (not x4)))))) (or (and (not (not (and (not x2) (not x4)))) (or (or (or (and x0 x2) (and x4 x4)) (not (or x2 x4))) (and (not (and x0 x4)) (or (or x0 x2) (or x0 x2))))) (or (and (not (or (or x1 x1) (and x2 x0))) (not (and (not x2) (or x2 x2)))) (or (or (not (and x4 x4)) (or (and x0 x3) (not x1))) (and (not (not x4)) (or (or x0 x3) (not x1))))))) (and (or (and (or (or (and (or x3 x4) (or x2 x2)) (not (and x3 x0))) (or (not (and x2 x2)) (or (or x2 x1) (or x1 x1)))) (or (and (and (not x4) (not x1)) (or (and x1 x3) (and x3 x2))) (and (or (not x3) (or x2 x1)) (not (and x3 x2))))) (not (and (or (or (or x2 x3) (not x2)) (and (not x1) (not x2))) (or (and (or x3 x1) (and x3 x2)) (and (or x4 x2) (or x0 x4)))))) (and (or (and (or (not (and x4 x2)) (or (and x1 x3) (and x2 x3))) (or (not (and x0 x1)) (not (or x1 x2)))) (and (not (or (not x2) (or x3 x2))) (and (and (and x3 x3) (not x2)) (not (and x3 x3))))) (not (and (not (or (not x4) (not x3))) (or (or (and x1 x1) (not x0)) (and (not x0) (and x4 x3))))))))) +(assert (or (and (or (or (and x2 x2) (or x1 x2)) (or (or x2 x3) (not x0))) (not (not (not x3)))) (or (and (and (and x3 x4) (or x4 x4)) (and (or x0 x2) (and x2 x3))) (and (or (and x4 x4) (and x2 x1)) (or (not x3) (or x4 x4)))))) +(check-sat) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_19.smt2 b/test/regress/regress1/push-pop/fuzz_19.smt2 new file mode 100644 index 000000000..cbfda64df --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_19.smt2 @@ -0,0 +1,44 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (or (not (and (not (or (or (and (not (and x0 x3)) (not (not x1))) (or (not (and x4 x4)) (or (not x4) (not x4)))) (or (not (or (or x4 x0) (and x4 x2))) (not (or (and x4 x0) (or x1 x3)))))) (not (or (and (or (or (or x4 x2) (and x3 x2)) (or (not x3) (or x3 x4))) (or (not (or x2 x2)) (and (or x1 x1) (not x4)))) (or (and (not (or x0 x4)) (and (or x0 x3) (not x0))) (not (and (and x1 x2) (and x1 x4)))))))) (not (and (not (and (or (and (not (or x0 x4)) (or (and x1 x4) (and x3 x3))) (or (or (not x3) (or x1 x1)) (not (not x4)))) (not (and (and (and x2 x4) (and x2 x4)) (not (not x4)))))) (and (and (not (not (or (not x4) (and x4 x0)))) (not (and (not (and x0 x0)) (or (not x4) (or x3 x2))))) (not (not (and (and (not x2) (and x4 x4)) (not (and x1 x2))))))))) (and (or (and (not (and (not (or (or (and x1 x2) (not x0)) (or (not x4) (and x3 x0)))) (or (not (or (or x1 x3) (not x0))) (and (or (or x3 x0) (and x2 x0)) (not (not x0)))))) (or (and (and (and (and (not x0) (and x0 x1)) (and (not x1) (or x1 x3))) (not (not (or x1 x1)))) (or (not (or (or x2 x3) (or x2 x1))) (or (not (not x4)) (and (and x0 x4) (not x0))))) (or (and (or (not (not x1)) (or (not x2) (or x1 x4))) (or (or (not x3) (not x4)) (not (and x2 x2)))) (or (and (or (and x3 x1) (and x1 x1)) (not (and x4 x2))) (and (or (not x2) (and x4 x3)) (and (not x2) (or x0 x2))))))) (and (or (and (or (or (and (not x1) (or x0 x4)) (not (not x3))) (not (or (or x3 x1) (and x1 x0)))) (or (and (or (and x3 x3) (not x3)) (or (and x0 x2) (not x4))) (and (not (not x2)) (and (and x3 x2) (and x4 x3))))) (and (not (not (or (not x2) (and x0 x3)))) (not (and (and (not x3) (not x4)) (not (not x4)))))) (or (not (or (not (not (not x2))) (and (and (not x0) (and x3 x4)) (or (not x4) (and x0 x1))))) (not (or (and (or (and x2 x1) (or x3 x2)) (not (and x1 x4))) (and (not (or x0 x4)) (not (not x1)))))))) (or (and (and (not (or (or (and (and x3 x0) (not x2)) (and (or x0 x4) (and x3 x2))) (and (or (and x1 x3) (and x2 x0)) (or (not x0) (or x0 x3))))) (not (not (and (or (and x4 x3) (or x1 x0)) (not (and x2 x3)))))) (not (or (not (and (and (and x3 x4) (or x3 x4)) (or (or x1 x2) (and x1 x4)))) (not (not (or (and x2 x2) (and x4 x4))))))) (or (or (not (or (or (or (or x2 x0) (not x2)) (or (not x0) (or x4 x4))) (or (or (and x2 x0) (or x1 x1)) (and (or x3 x0) (not x0))))) (or (or (and (not (not x3)) (not (and x3 x4))) (not (and (not x0) (not x0)))) (and (or (or (or x2 x3) (and x3 x0)) (or (or x0 x3) (or x2 x2))) (not (not (and x3 x0)))))) (or (or (not (or (not (not x4)) (and (and x4 x0) (and x2 x2)))) (or (and (or (or x4 x2) (and x0 x3)) (and (and x0 x3) (not x0))) (not (and (or x3 x0) (and x0 x4))))) (and (or (and (or (and x2 x2) (and x0 x2)) (not (not x1))) (not (or (and x1 x1) (and x1 x2)))) (and (not (not (not x2))) (or (or (not x1) (and x0 x4)) (or (not x0) (not x0))))))))))) +(assert (or (or (or (and x2 x1) (and x4 x4)) (or (or x1 x4) (and x2 x3))) (not (and (and x3 x4) (not x0))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (not (and (not (and (not (or (or x3 x0) (and x0 x2))) (not (and (and x2 x0) (not x3))))) (and (or (or (not (and x3 x1)) (not (and x4 x4))) (or (or (or x0 x3) (or x4 x4)) (not (not x3)))) (not (or (not (not x0)) (and (or x1 x0) (and x3 x2))))))) (not (and (and (and (or (or (or x2 x1) (and x0 x1)) (and (or x3 x0) (or x0 x0))) (or (and (and x3 x1) (or x3 x4)) (not (not x4)))) (not (and (or (and x2 x1) (and x4 x0)) (not (not x0))))) (and (and (or (or (and x3 x3) (or x1 x4)) (and (and x2 x3) (not x1))) (not (and (or x4 x2) (or x4 x4)))) (not (not (or (and x1 x1) (and x4 x3))))))))) +(assert (not (not (not (not (and (or (not (or (and (not x4) (not x2)) (and (not x4) (not x1)))) (not (and (and (and x2 x2) (and x4 x3)) (not (and x1 x0))))) (not (or (and (not (and x3 x2)) (not (not x2))) (not (not (not x2))))))))))) +(check-sat) +(push 1) +(assert (or (or (or (or (not x4) (not x1)) (not (not x1))) (and (and (and x4 x1) (and x4 x4)) (and (and x4 x0) (or x0 x2)))) (not (and (not (and x3 x0)) (and (not x2) (or x1 x0)))))) +(check-sat) +(pop 1) +(assert (not (or (not (not x3)) (or (not x2) (not x4))))) +(assert (and (or x3 x4) (and x4 x0))) +(assert (and (not (not (not (or (or (or (and (and (or x2 x3) (or x3 x1)) (and (or x0 x3) (and x4 x4))) (and (not (and x2 x4)) (or (and x4 x0) (or x4 x3)))) (not (or (and (and x0 x4) (not x4)) (not (or x3 x4))))) (and (and (or (not (and x1 x4)) (or (not x1) (and x4 x2))) (not (or (or x1 x2) (and x4 x3)))) (not (or (or (not x2) (not x4)) (and (or x1 x3) (not x3))))))))) (not (or (and (not (and (and (and (not (and x3 x3)) (not (and x1 x1))) (not (or (not x4) (or x2 x1)))) (and (not (or (not x4) (and x4 x2))) (or (or (and x1 x2) (not x4)) (and (or x3 x4) (not x0)))))) (and (or (or (or (or (or x3 x2) (or x1 x3)) (or (not x4) (or x1 x4))) (or (not (and x1 x0)) (and (and x4 x3) (and x0 x0)))) (and (or (not (not x0)) (or (or x0 x3) (or x4 x4))) (and (not (or x2 x2)) (not (and x2 x4))))) (or (not (and (or (and x1 x1) (or x1 x1)) (not (or x0 x0)))) (and (not (and (or x1 x3) (or x3 x3))) (or (and (or x0 x1) (not x2)) (or (or x3 x0) (or x3 x1))))))) (not (not (or (and (not (or (or x2 x2) (or x0 x3))) (or (and (and x4 x3) (not x4)) (or (or x0 x4) (and x3 x0)))) (and (or (and (or x1 x0) (or x0 x1)) (not (and x3 x4))) (and (or (or x2 x2) (or x1 x3)) (not (or x0 x1))))))))))) +(assert (or (not (and (and (or (and x3 x4) (not x3)) (not (or x1 x0))) (and (and (or x3 x2) (or x2 x1)) (and (and x0 x1) (and x0 x2))))) (not (not (or (not (not x1)) (or (or x1 x3) (or x1 x4))))))) +(check-sat) +(pop 1) +(assert (not (or x1 x2))) +(assert (or (and (or (or x2 x0) (not x4)) (or (not x4) (or x2 x2))) (not (not (or x2 x3))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_1_to_52_merged.smt2 b/test/regress/regress1/push-pop/fuzz_1_to_52_merged.smt2 new file mode 100644 index 000000000..5b225557f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_1_to_52_merged.smt2 @@ -0,0 +1,2282 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (not (and (or x4 x1) (and x5 x3))) (not (or (not x3) (not x3))))) +(assert (and (or (not (and (or (or x1 x0) (not x0)) (and (not x1) (and x5 x2)))) (not (and (and (and x3 x4) (and x0 x6)) (or (not x1) (and x4 x5))))) (or (or (and (not (and x1 x5)) (not (not x5))) (and (and (and x0 x6) (and x0 x4)) (not (not x5)))) (not (and (and (not x6) (and x0 x0)) (and (not x2) (not x2))))))) +(assert (or (not (or x6 x1)) (and (or x5 x1) (or x5 x6)))) +(assert (not (or (and (and (or (not (not (and x1 x0))) (not (and (or x1 x4) (or x6 x6)))) (not (not (not (or x4 x6))))) (and (or (or (or (and x2 x6) (and x1 x2)) (or (not x3) (not x3))) (or (or (and x4 x3) (and x2 x3)) (not (not x0)))) (and (not (and (and x4 x3) (not x2))) (or (and (or x0 x2) (not x2)) (or (not x3) (or x3 x3)))))) (and (not (not (or (or (or x5 x3) (or x4 x4)) (not (and x0 x6))))) (and (or (not (and (and x4 x5) (and x2 x6))) (or (and (and x2 x1) (and x3 x0)) (and (and x5 x4) (and x6 x2)))) (and (and (and (not x6) (not x4)) (and (and x0 x6) (not x4))) (not (and (or x4 x3) (not x6))))))))) +(assert (and (or (not (not (not (and (not (and x3 x0)) (and (or x6 x1) (not x1)))))) (not (and (not (or (and (or x3 x5) (and x0 x6)) (or (not x1) (not x4)))) (not (and (and (not x6) (and x1 x2)) (and (and x3 x0) (and x6 x0))))))) (or (not (or (and (and (or (and x1 x4) (not x0)) (not (and x6 x3))) (or (and (or x2 x6) (and x3 x5)) (not (not x0)))) (or (or (not (and x1 x6)) (or (or x3 x3) (and x0 x2))) (or (not (not x0)) (and (or x2 x6) (and x1 x6)))))) (not (and (and (and (or (and x0 x4) (and x3 x4)) (and (or x2 x6) (or x4 x4))) (or (and (or x3 x0) (or x5 x6)) (not (or x4 x0)))) (and (and (or (or x5 x2) (not x5)) (or (and x6 x1) (or x0 x4))) (not (and (and x6 x6) (not x3))))))))) +(assert (or (or x5 x5) (or x0 x3))) +(check-sat) +(push 1) +(assert (not (and (not x6) (not x2)))) +(assert (not (or (and (not (not (or (and (not (and x3 x0)) (not (or x6 x3))) (and (or (or x5 x0) (or x1 x1)) (or (or x4 x4) (or x5 x1)))))) (or (or (or (not (or (or x6 x2) (or x3 x5))) (and (not (not x4)) (not (and x6 x1)))) (and (or (and (and x6 x6) (and x2 x3)) (not (or x3 x3))) (or (or (not x0) (or x3 x2)) (and (not x5) (and x5 x4))))) (and (not (and (or (or x0 x0) (not x6)) (and (not x3) (not x3)))) (not (not (and (and x0 x0) (not x0))))))) (not (or (and (not (not (not (or x1 x1)))) (not (not (and (not x2) (or x6 x2))))) (or (or (and (or (or x2 x6) (or x6 x1)) (and (not x0) (and x4 x0))) (not (not (and x5 x2)))) (and (not (not (or x4 x1))) (or (and (not x4) (or x0 x5)) (or (and x1 x5) (not x5)))))))))) +(assert (and (or (and (and (or (not (and (not (and (and x1 x4) (and x1 x6))) (not (and (not x2) (and x1 x2))))) (not (or (or (or (or x3 x1) (or x5 x4)) (or (or x2 x4) (or x5 x2))) (not (and (or x3 x6) (not x0)))))) (or (or (and (not (or (not x5) (not x5))) (or (or (and x2 x2) (not x5)) (not (or x0 x5)))) (not (and (and (and x1 x3) (not x2)) (and (and x2 x1) (not x0))))) (and (not (or (and (not x2) (or x3 x2)) (and (not x3) (and x2 x5)))) (not (or (and (or x2 x2) (not x4)) (or (not x4) (not x1))))))) (and (and (or (and (not (and (not x0) (and x0 x4))) (and (and (not x6) (or x6 x2)) (or (and x5 x3) (and x5 x1)))) (and (or (and (not x0) (and x1 x4)) (not (or x2 x4))) (not (and (or x2 x5) (and x2 x2))))) (or (and (not (or (and x5 x5) (or x3 x1))) (not (not (not x3)))) (or (not (not (not x1))) (and (or (and x1 x4) (not x0)) (or (and x1 x0) (not x6)))))) (or (and (or (and (or (not x2) (and x4 x0)) (not (or x3 x1))) (or (or (or x0 x6) (or x2 x5)) (or (and x4 x4) (and x3 x2)))) (and (and (and (and x6 x1) (and x2 x3)) (or (not x1) (or x1 x4))) (or (and (or x6 x4) (not x3)) (or (or x1 x1) (and x5 x2))))) (or (or (or (not (not x4)) (and (not x0) (and x6 x6))) (or (and (not x4) (and x5 x2)) (not (not x4)))) (not (and (or (or x0 x3) (and x3 x5)) (not (not x2)))))))) (not (and (and (not (or (and (or (or x4 x3) (not x4)) (or (and x2 x5) (and x0 x3))) (and (and (or x2 x5) (or x1 x0)) (or (or x6 x4) (and x3 x2))))) (or (not (or (or (or x1 x5) (or x5 x3)) (not (not x1)))) (and (and (not (not x4)) (or (not x1) (and x1 x6))) (not (and (not x0) (not x6)))))) (not (or (and (or (and (not x1) (or x2 x4)) (not (or x5 x3))) (not (or (not x1) (not x0)))) (not (or (not (or x5 x1)) (and (or x1 x0) (and x1 x0))))))))) (or (or (and (and (not (not (not (or (or x3 x1) (or x6 x4))))) (or (not (not (and (and x2 x4) (and x0 x5)))) (and (and (and (and x4 x4) (or x5 x5)) (not (not x3))) (or (not (not x5)) (not (and x4 x1)))))) (and (or (and (or (not (and x6 x6)) (or (or x5 x1) (and x1 x2))) (not (not (and x1 x2)))) (and (and (or (and x3 x6) (not x4)) (and (not x5) (or x6 x5))) (not (and (not x5) (or x4 x3))))) (or (not (not (and (not x6) (and x3 x0)))) (or (and (and (and x3 x1) (and x6 x5)) (and (or x2 x5) (not x0))) (and (and (not x1) (not x6)) (not (not x3))))))) (not (and (not (not (not (and (or x6 x3) (not x6))))) (and (not (and (and (and x0 x0) (not x4)) (not (or x6 x1)))) (or (not (or (not x3) (not x5))) (or (or (not x6) (not x5)) (and (or x2 x6) (not x2)))))))) (and (and (not (or (and (not (not (or x5 x3))) (not (not (not x1)))) (not (not (not (and x2 x3)))))) (not (and (or (or (or (not x2) (or x2 x2)) (and (not x3) (or x4 x4))) (not (not (not x0)))) (and (and (and (and x5 x6) (or x1 x5)) (or (or x6 x1) (and x6 x1))) (and (not (or x0 x1)) (and (not x4) (and x5 x0))))))) (not (and (or (not (or (not (and x4 x6)) (or (not x5) (or x5 x0)))) (and (or (and (or x6 x1) (or x6 x1)) (and (not x2) (and x2 x0))) (or (not (and x5 x5)) (not (or x0 x5))))) (not (and (and (and (and x5 x1) (or x5 x2)) (and (and x3 x3) (or x2 x5))) (or (not (not x5)) (not (not x5))))))))))) +(check-sat) +(push 1) +(assert (not (or (and (and (not (or (and (or x4 x2) (or x0 x4)) (and (or x5 x2) (or x0 x5)))) (and (not (or (not x4) (and x4 x5))) (or (or (or x4 x5) (not x5)) (and (not x4) (or x0 x6))))) (or (and (not (not (not x6))) (or (and (not x1) (or x4 x3)) (or (or x5 x2) (or x6 x6)))) (and (not (and (or x4 x6) (not x1))) (or (or (and x2 x4) (and x3 x3)) (and (or x5 x0) (and x4 x2)))))) (not (not (and (not (not (and x1 x3))) (or (and (or x6 x5) (not x5)) (not (or x6 x5))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (not (or x6 x3)) (or (and x5 x4) (and x1 x0)))) +(assert (not (not (not x1)))) +(assert (and (not (not (or (and x3 x5) (and x6 x3)))) (and (and (not (not x4)) (or (or x5 x5) (or x4 x4))) (or (not (not x0)) (and (and x1 x3) (or x4 x6)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (or x2 x3) (or x1 x5))) +(check-sat) +(pop 1) +(assert (and (or (or (or (or (and (or x1 x3) (and x2 x6)) (or (not x1) (not x1))) (or (not (and x6 x2)) (and (not x1) (or x1 x3)))) (and (and (or (and x3 x4) (not x5)) (and (or x6 x4) (and x6 x3))) (and (not (not x2)) (and (not x2) (or x2 x2))))) (and (and (not (not (and x0 x3))) (or (or (or x4 x4) (or x0 x1)) (or (not x3) (and x3 x5)))) (or (and (and (not x0) (and x4 x2)) (not (not x2))) (and (not (or x4 x1)) (not (and x1 x5)))))) (and (not (or (not (or (or x6 x6) (and x0 x4))) (and (and (not x6) (not x0)) (and (or x0 x0) (and x2 x2))))) (and (or (and (or (not x1) (or x3 x0)) (or (and x3 x2) (or x2 x3))) (and (not (not x1)) (and (and x1 x4) (or x2 x2)))) (not (not (and (or x5 x2) (and x3 x5)))))))) +(check-sat) +(pop 1) +(assert (not (and (not (and (and (or (and (not (not (and x0 x2))) (or (or (not x1) (and x6 x5)) (and (and x6 x0) (and x6 x4)))) (and (or (or (and x0 x0) (or x1 x5)) (not (or x5 x2))) (not (or (not x5) (or x1 x3))))) (not (not (not (or (or x4 x1) (or x0 x1)))))) (not (and (and (not (not (or x3 x3))) (or (and (not x3) (or x5 x6)) (and (not x5) (not x4)))) (and (not (not (and x1 x0))) (or (or (not x2) (and x3 x6)) (not (or x1 x0)))))))) (not (and (not (and (or (or (and (or x1 x3) (not x6)) (not (not x0))) (not (and (not x1) (not x5)))) (or (and (not (and x0 x6)) (and (and x6 x6) (and x2 x4))) (or (or (or x5 x5) (or x1 x0)) (or (and x6 x4) (and x0 x3)))))) (not (not (or (not (and (not x3) (not x5))) (not (and (and x6 x4) (and x2 x0))))))))))) +(check-sat) +(pop 1) +(assert (and (and (or (and (or (or (or (not (and (or x1 x0) (or x5 x0))) (and (not (not x2)) (not (or x4 x6)))) (or (not (or (or x4 x2) (not x0))) (not (or (not x1) (and x1 x3))))) (and (and (not (not (or x0 x6))) (or (and (and x5 x4) (not x3)) (not (and x3 x5)))) (not (and (or (or x0 x5) (or x3 x6)) (not (not x5)))))) (not (or (or (and (and (or x0 x5) (and x2 x3)) (not (not x1))) (not (not (and x0 x6)))) (or (and (and (and x4 x4) (not x0)) (not (not x3))) (or (and (not x0) (and x5 x0)) (or (and x6 x3) (not x2))))))) (not (not (not (or (and (or (and x2 x5) (and x2 x2)) (not (and x1 x1))) (and (or (and x5 x1) (or x5 x5)) (and (or x4 x5) (not x0)))))))) (or (not (not (or (or (and (not (or x4 x4)) (and (not x4) (and x0 x3))) (and (and (and x3 x4) (and x6 x1)) (or (not x5) (or x3 x3)))) (or (not (and (or x2 x5) (not x1))) (not (or (and x5 x4) (not x6))))))) (or (or (not (not (or (or (and x4 x4) (not x0)) (not (or x0 x2))))) (and (not (not (and (or x5 x6) (not x4)))) (or (or (not (and x3 x5)) (and (not x0) (and x2 x4))) (and (or (and x0 x4) (or x1 x2)) (or (and x4 x1) (and x5 x3)))))) (not (not (and (and (not (not x5)) (and (and x3 x2) (and x2 x2))) (or (or (and x0 x6) (or x4 x0)) (and (or x2 x3) (and x4 x2))))))))) (or (or (and (or (not (not (or (not (and x1 x6)) (or (or x5 x6) (not x3))))) (and (and (and (and (not x5) (and x5 x3)) (or (or x4 x1) (not x2))) (not (or (and x4 x3) (or x6 x1)))) (not (or (not (not x4)) (or (not x0) (and x2 x2)))))) (not (or (or (and (or (and x3 x4) (not x2)) (and (or x6 x0) (not x4))) (and (not (not x2)) (or (not x0) (or x4 x5)))) (or (not (or (and x5 x3) (not x5))) (not (not (not x4))))))) (not (and (and (not (not (or (not x0) (not x3)))) (not (not (or (not x5) (and x1 x3))))) (and (or (not (and (not x2) (not x0))) (not (and (and x5 x5) (and x4 x3)))) (or (not (and (not x1) (and x5 x0))) (and (and (or x4 x5) (or x5 x3)) (not (not x1)))))))) (and (not (not (or (and (or (not (or x6 x0)) (or (or x3 x2) (not x5))) (not (and (and x1 x4) (not x1)))) (and (or (and (and x2 x3) (or x2 x1)) (not (or x4 x0))) (not (or (not x3) (and x3 x5))))))) (or (or (or (or (not (and (and x5 x1) (or x4 x1))) (not (or (and x3 x1) (or x5 x0)))) (or (not (or (not x2) (and x3 x5))) (or (or (and x3 x5) (and x3 x3)) (not (not x1))))) (not (and (not (not (and x2 x2))) (or (and (not x3) (and x1 x1)) (not (or x3 x4)))))) (or (not (not (or (and (or x2 x2) (not x5)) (or (not x5) (not x2))))) (or (not (and (or (not x3) (and x6 x6)) (not (not x5)))) (or (and (or (and x5 x0) (and x2 x0)) (and (and x0 x2) (not x1))) (and (or (or x5 x6) (and x2 x1)) (or (and x4 x1) (and x1 x0))))))))))) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(assert (not (not (or (or (not (or (not (or (or (not x3) (or x3 x3)) (not (not x3)))) (and (not (and (and x2 x1) (not x3))) (and (or (or x3 x1) (not x5)) (or (not x3) (or x4 x0)))))) (and (not (or (not (and (and x3 x0) (and x4 x5))) (or (not (and x0 x0)) (and (and x5 x4) (not x3))))) (and (and (or (not (and x3 x0)) (or (not x2) (or x5 x1))) (not (and (and x2 x0) (or x5 x4)))) (not (or (not (and x2 x1)) (or (not x4) (and x3 x5))))))) (or (or (and (and (or (not (or x5 x0)) (or (not x2) (not x3))) (not (not (and x1 x1)))) (and (or (or (or x2 x5) (not x1)) (or (or x2 x0) (and x0 x4))) (or (and (and x3 x5) (and x1 x4)) (and (or x5 x0) (and x1 x2))))) (not (or (not (or (and x2 x2) (or x4 x3))) (not (or (or x3 x4) (and x0 x0)))))) (or (not (not (not (and (and x1 x2) (or x5 x0))))) (or (and (or (and (and x0 x5) (and x0 x3)) (or (or x2 x0) (or x3 x3))) (or (and (or x4 x4) (or x0 x5)) (not (not x5)))) (or (not (or (or x4 x1) (and x4 x2))) (and (not (not x5)) (or (or x5 x4) (and x2 x1))))))))))) +(check-sat) +(push 1) +(assert (not (not (not x1)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (or (or (or (and (or (and (and (not (and x1 x4)) (and (not x1) (not x1))) (or (not (or x2 x4)) (or (not x5) (and x2 x4)))) (or (not (and (and x0 x2) (and x2 x3))) (or (and (not x1) (or x4 x3)) (or (not x4) (and x2 x0))))) (not (not (and (or (not x3) (and x5 x0)) (not (and x1 x4)))))) (not (and (not (not (and (or x1 x4) (not x5)))) (not (and (not (and x2 x5)) (not (or x1 x4))))))) (and (and (or (or (and (or (or x1 x4) (not x5)) (and (and x3 x1) (or x4 x2))) (not (or (or x4 x4) (not x4)))) (and (and (or (and x1 x4) (and x3 x0)) (not (not x0))) (not (and (or x2 x3) (not x3))))) (and (and (and (not (not x3)) (and (not x5) (or x1 x3))) (not (and (and x4 x0) (and x5 x3)))) (not (and (and (not x1) (not x3)) (and (or x1 x5) (not x5)))))) (or (and (and (and (not (or x5 x3)) (or (or x3 x2) (not x1))) (not (and (not x3) (or x3 x1)))) (or (or (and (and x5 x5) (not x4)) (and (not x3) (not x1))) (not (or (not x1) (and x3 x2))))) (not (not (not (or (not x0) (or x1 x0)))))))) (not (not (or (not (and (not (and (or x5 x5) (not x2))) (not (not (and x5 x0))))) (or (and (and (and (and x1 x4) (or x0 x4)) (and (or x3 x4) (not x5))) (or (and (and x5 x3) (not x5)) (and (and x5 x3) (not x0)))) (or (not (and (or x5 x2) (and x0 x5))) (or (or (and x4 x4) (and x3 x0)) (and (or x3 x3) (or x0 x3))))))))) (or (not (or (not (and (not (or (and (and x5 x2) (and x5 x4)) (not (and x4 x2)))) (not (not (and (or x3 x5) (not x1)))))) (or (or (not (and (or (not x4) (and x3 x5)) (or (or x4 x0) (not x1)))) (and (or (or (or x1 x1) (and x5 x1)) (not (or x5 x5))) (not (or (or x3 x3) (not x5))))) (and (and (or (and (or x2 x2) (not x2)) (or (and x1 x3) (and x3 x4))) (or (and (and x0 x1) (not x5)) (and (not x3) (and x3 x5)))) (and (or (or (not x0) (not x3)) (not (not x1))) (not (not (not x4)))))))) (not (not (and (not (not (or (or (not x1) (or x2 x0)) (or (and x5 x4) (or x3 x4))))) (and (and (and (and (and x5 x3) (or x1 x4)) (or (or x1 x5) (not x3))) (not (not (not x0)))) (not (or (or (not x3) (and x5 x1)) (not (and x5 x4))))))))))) +(assert (not (and (and (and (not (or (not x3) (and x0 x2))) (and (not (not x5)) (not (not x1)))) (not (or (or (or x5 x1) (not x5)) (not (not x3))))) (and (not (and (or (or x2 x2) (and x5 x5)) (not (not x5)))) (not (not (not (and x4 x2)))))))) +(assert (not (or (not (not (and (and (not (and (and x3 x5) (or x4 x3))) (and (and (or x0 x1) (and x3 x1)) (and (not x0) (and x4 x3)))) (and (and (not (or x0 x4)) (or (not x3) (not x1))) (or (or (or x4 x5) (and x3 x4)) (or (and x5 x2) (and x4 x0))))))) (not (or (not (or (and (or (or x3 x4) (or x5 x2)) (not (or x1 x0))) (or (not (not x0)) (not (and x1 x4))))) (not (not (or (and (and x0 x2) (or x1 x1)) (not (not x5)))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (and (or (or (or (not x0) (or x1 x4)) (not (not x4))) (and (and (or x0 x1) (not x1)) (or (and x4 x5) (and x4 x5)))) (or (and (and (or x3 x3) (or x4 x0)) (or (and x1 x2) (and x3 x2))) (or (not (or x0 x0)) (not (and x5 x0))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (or (or x5 x1) (or x3 x0)) (and (and x2 x3) (or x3 x5))) (or (and (not x3) (or x0 x3)) (and (not x3) (or x4 x0))))) +(assert (not (and (and (not x2) (or x0 x5)) (and (not x1) (or x3 x1))))) +(assert (not (or (or x3 x4) (or x5 x5)))) +(assert (and (not (and (and (or (or (or (not (or x3 x3)) (and (not x4) (or x1 x0))) (and (or (not x4) (or x0 x5)) (and (not x2) (and x2 x3)))) (and (or (or (not x2) (and x4 x3)) (and (not x0) (not x0))) (or (and (and x1 x4) (not x1)) (and (and x2 x2) (or x4 x5))))) (and (not (and (and (and x5 x5) (and x5 x1)) (or (not x4) (not x0)))) (or (not (or (not x1) (not x1))) (or (and (not x0) (and x2 x4)) (or (and x5 x3) (and x2 x2)))))) (and (not (and (or (and (and x3 x5) (or x3 x3)) (or (and x5 x1) (and x4 x5))) (not (and (or x5 x1) (not x5))))) (or (and (or (not (or x5 x0)) (or (or x1 x2) (not x4))) (not (not (not x0)))) (not (and (or (and x2 x2) (and x2 x1)) (not (and x2 x1)))))))) (not (or (not (not (not (and (not (or x1 x3)) (and (and x5 x0) (or x4 x5)))))) (or (and (and (or (or (and x5 x4) (and x4 x3)) (or (and x2 x2) (and x3 x2))) (not (and (and x5 x0) (not x4)))) (and (and (not (and x3 x2)) (and (not x1) (not x5))) (or (or (and x1 x4) (not x2)) (not (or x5 x2))))) (or (and (not (and (and x5 x4) (or x1 x3))) (or (and (and x0 x0) (or x3 x5)) (not (not x2)))) (not (and (and (not x2) (and x1 x0)) (and (and x3 x0) (and x5 x5)))))))))) +(assert (or (not (and (and (or (or (and (and (or (not x4) (not x0)) (or (or x2 x0) (not x2))) (not (and (not x3) (and x3 x3)))) (not (or (and (or x1 x4) (and x3 x2)) (and (or x4 x3) (and x4 x5))))) (not (and (or (or (or x3 x5) (or x5 x4)) (or (or x5 x1) (not x0))) (and (or (or x1 x5) (and x4 x1)) (and (or x3 x5) (not x5)))))) (and (and (or (and (and (not x3) (and x3 x2)) (or (or x3 x3) (and x5 x3))) (and (or (not x2) (not x4)) (and (and x2 x2) (and x1 x5)))) (and (not (and (not x5) (and x4 x2))) (not (not (and x0 x0))))) (not (and (not (not (and x0 x2))) (and (or (not x3) (not x3)) (not (not x5))))))) (not (and (and (not (and (or (and x2 x3) (or x2 x0)) (or (or x0 x3) (and x4 x4)))) (or (and (and (not x5) (and x0 x2)) (not (or x1 x2))) (not (and (or x3 x5) (not x4))))) (not (or (or (and (or x4 x4) (not x5)) (or (or x3 x4) (not x0))) (and (not (and x1 x4)) (and (not x4) (and x5 x2))))))))) (and (not (not (and (and (and (not (not (not x0))) (or (not (or x4 x5)) (or (and x1 x5) (not x2)))) (not (and (and (and x3 x4) (not x1)) (and (not x3) (and x1 x5))))) (or (not (and (or (not x2) (and x1 x5)) (not (and x3 x2)))) (or (and (and (or x1 x3) (or x5 x0)) (not (or x1 x3))) (not (not (not x4)))))))) (not (not (and (not (or (and (and (not x3) (not x2)) (not (or x4 x2))) (and (and (or x5 x1) (or x3 x5)) (not (and x4 x3))))) (or (or (not (not (or x3 x1))) (not (or (or x4 x0) (and x0 x3)))) (or (not (not (or x0 x3))) (or (and (not x2) (not x1)) (and (or x5 x0) (and x4 x5))))))))))) +(check-sat) +(push 1) +(assert (or (and (and (not (not (not (and (or (or x3 x0) (or x3 x1)) (not (not x2)))))) (not (not (or (and (or (and x4 x0) (not x4)) (not (or x4 x1))) (and (or (not x1) (or x3 x2)) (or (or x5 x1) (not x1))))))) (and (not (and (or (not (and (or x3 x1) (not x2))) (and (and (and x4 x5) (not x5)) (and (and x0 x0) (and x1 x2)))) (not (not (or (not x2) (and x3 x1)))))) (not (or (or (or (and (not x0) (and x4 x5)) (or (not x2) (and x2 x1))) (not (or (not x0) (not x0)))) (and (not (and (and x2 x0) (not x5))) (or (and (or x4 x0) (not x0)) (or (and x4 x3) (or x4 x5)))))))) (and (and (not (and (and (and (not (and x3 x0)) (and (not x1) (or x5 x1))) (or (not (not x1)) (not (or x0 x2)))) (and (or (not (not x0)) (or (and x4 x4) (and x2 x4))) (or (not (not x4)) (not (and x3 x4)))))) (not (or (not (not (and (or x0 x0) (or x4 x0)))) (not (and (not (not x4)) (or (and x0 x5) (or x3 x3))))))) (and (not (not (not (or (and (or x2 x3) (and x2 x2)) (not (or x0 x3)))))) (or (or (and (or (and (or x2 x4) (and x1 x4)) (and (and x5 x1) (not x0))) (not (not (or x0 x3)))) (not (and (and (not x4) (not x2)) (or (not x1) (or x3 x4))))) (not (and (not (or (or x4 x2) (and x2 x5))) (or (not (not x5)) (not (not x3)))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (and (not x3) (not x3)) (and (and x2 x3) (or x4 x1)))) +(assert (not (and (or (or (and (or (or (or (or x4 x0) (and x3 x0)) (or (or x3 x4) (not x4))) (or (or (and x2 x4) (and x4 x2)) (not (or x4 x0)))) (or (and (or (and x2 x4) (or x1 x0)) (and (not x1) (and x0 x5))) (or (and (not x4) (not x3)) (not (not x1))))) (not (or (and (and (or x3 x1) (or x2 x3)) (or (not x5) (and x4 x5))) (not (and (or x5 x2) (not x5)))))) (or (or (or (or (or (and x0 x5) (or x1 x4)) (not (and x1 x2))) (or (or (not x1) (or x4 x5)) (and (and x5 x0) (not x4)))) (or (or (or (or x0 x5) (and x0 x0)) (and (or x1 x2) (not x3))) (not (or (or x3 x1) (or x4 x0))))) (not (and (not (or (or x0 x3) (not x0))) (or (or (and x0 x5) (or x4 x3)) (or (and x4 x0) (or x0 x2))))))) (and (and (or (or (not (and (and x4 x0) (and x2 x1))) (and (or (and x3 x3) (and x2 x1)) (not (not x5)))) (not (not (and (not x3) (not x0))))) (or (and (and (and (and x3 x0) (or x2 x1)) (not (not x0))) (and (not (not x4)) (or (and x0 x1) (or x3 x4)))) (and (or (or (and x4 x2) (and x2 x0)) (or (and x5 x1) (not x0))) (and (and (not x1) (and x5 x0)) (or (or x0 x3) (and x5 x3)))))) (not (or (and (not (and (or x5 x3) (and x5 x1))) (or (or (and x2 x3) (or x3 x2)) (or (and x0 x5) (not x5)))) (or (or (not (not x5)) (or (and x0 x3) (and x5 x0))) (or (not (or x2 x1)) (or (or x3 x5) (and x0 x0)))))))))) +(check-sat) +(pop 1) +(assert (or (and (and (and (not x1) (or x5 x5)) (and (or x2 x1) (not x0))) (and (not (or x1 x3)) (and (not x0) (or x3 x5)))) (or (or (and (or x0 x2) (not x1)) (and (and x3 x2) (or x0 x5))) (and (or (or x0 x0) (and x2 x5)) (or (or x0 x3) (not x1)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (not (and (or (not (not (or (not (not x5)) (and (not x5) (not x1))))) (and (not (or (or (or x0 x0) (not x5)) (not (or x5 x2)))) (or (or (not (or x3 x2)) (or (not x2) (or x5 x5))) (or (and (not x2) (and x0 x2)) (and (and x5 x5) (or x3 x4)))))) (not (not (or (not (not (and x2 x2))) (and (and (not x2) (or x5 x0)) (or (not x4) (and x5 x4)))))))) (or (and (and (not (not (or (and (or x0 x0) (or x4 x1)) (or (and x5 x4) (or x1 x2))))) (and (and (not (and (and x0 x0) (or x5 x3))) (or (or (and x4 x3) (not x2)) (and (not x0) (not x3)))) (and (or (and (not x3) (not x1)) (not (not x0))) (or (and (and x4 x1) (not x0)) (and (not x0) (not x5)))))) (not (not (and (not (and (and x3 x3) (or x5 x5))) (and (or (not x4) (and x4 x3)) (and (and x4 x3) (or x4 x5))))))) (and (or (not (not (not (and (not x3) (or x4 x4))))) (or (not (not (or (not x2) (and x5 x4)))) (or (and (or (and x3 x5) (or x0 x1)) (and (not x2) (not x1))) (not (or (or x2 x0) (and x0 x2)))))) (and (and (not (and (or (not x3) (or x4 x1)) (and (or x2 x1) (not x0)))) (and (and (not (or x2 x2)) (not (not x3))) (or (and (and x2 x2) (or x4 x0)) (or (or x1 x2) (and x1 x5))))) (or (not (not (not (or x2 x3)))) (not (not (or (not x4) (or x3 x0)))))))))) +(check-sat) +(push 1) +(assert (and (or (not (not (not (or (not x0) (and x3 x1))))) (or (not (not (or (not x2) (and x2 x3)))) (or (and (or (and x0 x3) (not x4)) (or (not x0) (not x1))) (or (and (or x4 x5) (and x0 x2)) (not (and x2 x5)))))) (not (not (not (and (and (not x1) (and x1 x0)) (not (and x2 x4)))))))) +(assert (not x0)) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(assert (not (and (not (and (or (not (or (not x0) (or x2 x2))) (or (or (or x2 x1) (or x1 x3)) (not (or x3 x2)))) (or (not (not (and x1 x2))) (and (not (not x2)) (and (or x0 x2) (or x0 x1)))))) (not (not (or (or (and (or x0 x1) (not x3)) (and (or x3 x3) (and x3 x1))) (not (or (or x0 x2) (or x2 x3))))))))) +(assert (and (not (and (and (not (not (not x2))) (and (or (or x3 x0) (not x1)) (and (or x0 x0) (and x1 x1)))) (and (and (and (and x0 x3) (and x2 x1)) (or (not x3) (not x0))) (not (and (and x2 x0) (and x2 x1)))))) (and (or (or (and (not (or x0 x1)) (not (and x2 x3))) (and (not (not x0)) (or (or x3 x1) (or x1 x2)))) (or (or (or (not x0) (and x0 x1)) (and (and x2 x2) (or x3 x3))) (or (not (or x1 x1)) (and (and x0 x3) (and x3 x2))))) (or (not (not (not (and x3 x1)))) (or (and (not (and x0 x2)) (not (or x0 x1))) (and (not (and x3 x3)) (not (not x1)))))))) +(assert (not (and x0 x3))) +(check-sat) +(push 1) +(assert (or (or (or x0 x1) (and x0 x1)) (or (and x0 x2) (not x1)))) +(assert (or (or (or (or (not (not (or (or (or x3 x2) (not x1)) (or (and x3 x2) (not x3))))) (not (and (not (and (or x1 x0) (or x0 x1))) (or (and (or x1 x3) (or x1 x1)) (and (and x0 x3) (and x2 x0)))))) (and (and (not (not (and (and x3 x3) (not x3)))) (not (or (or (and x0 x0) (not x2)) (not (and x1 x1))))) (not (or (and (or (or x1 x0) (or x2 x2)) (and (and x2 x2) (not x1))) (not (not (not x0))))))) (or (not (and (not (and (or (and x0 x0) (not x1)) (or (not x3) (or x0 x1)))) (not (and (and (or x3 x1) (or x1 x2)) (not (not x3)))))) (and (not (not (and (or (not x2) (not x1)) (and (not x3) (or x0 x3))))) (or (or (and (not (or x1 x3)) (or (not x0) (and x1 x3))) (and (not (or x2 x2)) (or (and x1 x3) (or x1 x1)))) (not (not (not (or x1 x3)))))))) (and (not (not (not (or (not (or (or x1 x2) (not x2))) (or (or (or x3 x3) (or x1 x0)) (and (and x3 x3) (not x1))))))) (and (not (not (or (or (and (or x0 x3) (or x0 x0)) (and (and x2 x3) (not x3))) (or (or (not x3) (and x3 x3)) (not (not x2)))))) (and (not (and (not (or (or x1 x0) (not x2))) (and (and (or x0 x0) (and x2 x2)) (not (and x2 x0))))) (and (and (or (and (or x2 x1) (not x1)) (not (not x1))) (not (not (and x0 x0)))) (not (not (not (and x0 x1)))))))))) +(assert (or (not (or (not x1) (or x1 x1))) (and (not (or x0 x3)) (or (and x1 x3) (not x3))))) +(assert (not (and (not (or (and (or x2 x1) (and x3 x0)) (and (not x1) (or x0 x3)))) (or (not (not (and x2 x3))) (and (and (and x0 x2) (not x0)) (or (and x0 x1) (not x0))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (not (and x3 x2)) (or (and x2 x1) (not x0)))) +(assert (or (or (not (or (and (not x0) (not x0)) (not (and x0 x3)))) (not (or (and (and x3 x1) (or x0 x0)) (and (and x0 x3) (and x3 x3))))) (or (and (or (and (not x0) (or x1 x1)) (not (or x2 x0))) (not (or (and x0 x2) (and x0 x0)))) (not (and (or (or x2 x0) (and x2 x3)) (and (or x2 x0) (not x0))))))) +(assert (not (not (or (or x0 x3) (or x1 x2))))) +(assert (or (and (or (and x0 x0) (and x3 x0)) (not (and x0 x0))) (not (or (and x2 x2) (not x1))))) +(check-sat) +(pop 1) +(assert (and (or (not (and x2 x2)) (and (and x2 x3) (not x3))) (and (not (or x0 x1)) (not (and x1 x2))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(assert (and (not (and (and (not (or (or (or x1 x2) (and x1 x2)) (and (and x2 x0) (not x2)))) (not (or (and (or x0 x2) (and x2 x1)) (not (or x1 x0))))) (not (and (not (not (and x1 x0))) (not (and (not x1) (or x1 x1))))))) (or (or (or (not (not (not (and x0 x0)))) (not (and (not (and x1 x2)) (not (not x2))))) (or (not (not (and (and x0 x2) (not x0)))) (and (and (not (not x2)) (not (and x0 x1))) (or (and (not x0) (and x1 x0)) (not (not x1)))))) (or (not (or (or (or (not x0) (and x0 x0)) (not (or x1 x1))) (or (not (or x0 x0)) (or (not x1) (or x1 x2))))) (and (or (not (not (and x0 x2))) (or (and (or x1 x1) (or x0 x0)) (and (or x1 x0) (not x1)))) (or (not (or (or x1 x2) (not x1))) (and (and (or x0 x1) (or x1 x2)) (or (not x1) (and x1 x0))))))))) +(check-sat) +(push 1) +(assert (and (or (not (not x2)) (and (not x2) (and x0 x0))) (and (not (and x1 x0)) (or (not x2) (or x0 x1))))) +(assert (or (or x2 x2) (not x2))) +(check-sat) +(pop 1) +(assert (or (and (not (not (and (and (or (not (and (not x2) (or x0 x2))) (not (or (or x0 x2) (not x1)))) (or (not (and (not x2) (and x2 x0))) (and (or (and x0 x0) (and x2 x2)) (not (not x1))))) (not (and (and (or (and x1 x1) (and x2 x0)) (and (and x1 x0) (or x1 x0))) (and (not (and x0 x0)) (or (and x0 x2) (and x0 x2)))))))) (or (not (not (not (and (not (and (and x0 x0) (or x1 x2))) (not (or (or x2 x1) (not x2))))))) (and (or (not (and (and (and (and x1 x0) (or x1 x1)) (not (or x2 x0))) (or (or (and x1 x1) (or x2 x1)) (not (or x2 x0))))) (or (and (or (and (not x0) (or x1 x2)) (not (not x0))) (not (and (and x2 x1) (and x1 x2)))) (not (or (or (and x0 x1) (or x1 x2)) (or (not x2) (not x2)))))) (not (and (not (or (or (and x2 x0) (not x0)) (not (not x2)))) (and (or (or (and x0 x1) (and x2 x2)) (or (or x0 x0) (or x2 x0))) (not (not (not x1))))))))) (not (not (not (and (or (not (and (or (and x1 x2) (or x1 x1)) (not (or x0 x1)))) (not (not (not (or x1 x2))))) (or (and (not (or (and x0 x2) (or x2 x1))) (not (not (and x1 x2)))) (and (not (or (not x2) (not x1))) (not (not (not x1))))))))))) +(assert (not x0)) +(check-sat) +(push 1) +(assert (not (or (or x2 x0) (and x1 x1)))) +(assert (or (or (not (and (or (not x0) (not x2)) (and (and x1 x1) (or x1 x0)))) (not (not (not (not x2))))) (and (not (or (and (not x1) (or x1 x1)) (not (not x1)))) (not (or (not (not x2)) (not (not x0))))))) +(assert (not (and x0 x0))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(check-sat) +(push 1) +(assert (not (not (or (and (not (and (or (not (or (not x4) (and x6 x0))) (or (and (and x4 x4) (not x1)) (not (not x0)))) (not (not (or (not x7) (or x1 x1)))))) (not (and (and (not (and (and x4 x3) (and x0 x4))) (and (not (and x5 x4)) (and (not x2) (or x5 x5)))) (not (not (not (not x3))))))) (not (not (and (or (not (not (and x7 x3))) (and (and (not x4) (or x3 x2)) (or (or x7 x0) (not x0)))) (not (not (or (and x7 x6) (or x1 x2))))))))))) +(assert (not (or (or (and (or (or (not (and x2 x1)) (and (or x4 x1) (or x4 x0))) (and (and (not x3) (not x6)) (not (or x5 x6)))) (not (not (and (or x6 x5) (not x4))))) (and (not (not (or (and x7 x6) (not x3)))) (or (and (not (not x4)) (and (not x0) (or x7 x2))) (and (and (or x3 x3) (not x6)) (or (or x0 x6) (or x1 x4)))))) (and (or (and (or (or (and x5 x1) (and x5 x5)) (or (or x5 x3) (or x0 x3))) (not (or (and x5 x1) (and x7 x6)))) (not (and (and (and x1 x7) (and x5 x4)) (and (not x1) (or x4 x6))))) (not (and (or (and (not x2) (and x6 x4)) (not (and x1 x6))) (not (not (or x7 x5))))))))) +(assert (or (not (or (and (and (and (and (not x2) (not x0)) (not (and x4 x5))) (and (or (not x7) (not x7)) (or (not x6) (or x4 x3)))) (or (or (not (not x1)) (or (not x5) (not x4))) (and (and (and x4 x4) (or x2 x1)) (and (not x7) (and x1 x2))))) (or (not (not (not (or x2 x7)))) (or (and (or (or x5 x2) (not x3)) (or (not x2) (and x6 x6))) (or (and (and x7 x3) (and x6 x2)) (not (not x0))))))) (and (and (or (and (or (or (or x5 x3) (or x3 x5)) (and (not x2) (or x0 x4))) (or (not (and x2 x7)) (or (not x2) (or x7 x6)))) (or (and (or (and x5 x0) (not x1)) (not (or x5 x6))) (not (not (or x6 x5))))) (or (and (and (and (and x3 x1) (or x4 x6)) (and (or x6 x4) (or x6 x5))) (or (and (not x1) (or x1 x6)) (or (and x6 x4) (and x4 x1)))) (not (and (not (and x7 x5)) (or (and x1 x3) (or x4 x1)))))) (or (and (or (or (and (not x6) (not x6)) (not (or x0 x6))) (or (not (not x5)) (or (and x7 x7) (or x6 x4)))) (or (or (and (or x1 x1) (not x5)) (and (not x6) (or x3 x4))) (or (not (not x1)) (or (or x1 x6) (or x6 x3))))) (and (not (or (not (and x6 x3)) (and (or x4 x6) (and x7 x3)))) (or (and (and (and x4 x6) (and x6 x2)) (or (and x4 x3) (and x0 x1))) (and (and (or x3 x7) (or x1 x2)) (and (not x7) (or x0 x6))))))))) +(check-sat) +(push 1) +(assert (or (not (or (not (or (or x2 x0) (and x5 x6))) (and (not (and x5 x6)) (or (or x2 x3) (not x3))))) (and (not (or (not (or x7 x6)) (or (not x6) (or x7 x7)))) (or (or (and (or x5 x6) (or x7 x4)) (not (not x2))) (or (or (or x2 x0) (and x1 x6)) (and (and x2 x2) (not x4))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (or (or (and x5 x3) (or x4 x4)) (and (not x4) (not x7))))) +(check-sat) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (or (or (or (or (or (or (and (not x3) (or x0 x1)) (and (and x3 x2) (not x7))) (and (not (or x3 x2)) (and (not x5) (or x1 x6)))) (and (and (or (and x4 x2) (or x4 x1)) (not (not x3))) (and (and (and x6 x5) (or x7 x4)) (not (or x3 x7))))) (or (or (or (or (and x3 x2) (or x6 x6)) (and (or x0 x2) (or x1 x0))) (or (or (or x1 x5) (and x6 x7)) (and (not x3) (not x5)))) (and (or (not (not x5)) (and (and x0 x2) (and x6 x4))) (not (or (or x0 x7) (not x0)))))) (and (or (and (not (not (not x0))) (or (and (or x1 x6) (not x2)) (not (and x7 x3)))) (and (not (not (not x5))) (not (and (or x0 x1) (not x0))))) (not (or (and (and (and x1 x1) (not x0)) (not (and x1 x0))) (or (not (not x5)) (and (or x7 x2) (not x7))))))) (and (or (not (and (and (and (or x6 x3) (not x4)) (and (or x5 x7) (or x6 x2))) (and (or (and x0 x3) (and x6 x6)) (and (and x0 x3) (not x0))))) (or (not (and (not (or x2 x6)) (or (and x2 x1) (and x0 x0)))) (or (and (not (and x5 x5)) (not (and x4 x4))) (and (not (or x7 x5)) (or (not x6) (or x3 x6)))))) (and (and (not (and (not (not x7)) (not (and x0 x6)))) (or (and (and (and x7 x1) (or x3 x5)) (not (or x7 x0))) (not (or (or x2 x1) (not x0))))) (or (or (not (not (or x2 x3))) (not (and (or x3 x5) (and x7 x7)))) (not (and (and (or x6 x3) (and x5 x3)) (and (not x2) (and x4 x5))))))))) (and (or (not (or (or (or (not (and (or x3 x2) (or x1 x0))) (and (not (or x6 x2)) (or (and x5 x4) (or x0 x6)))) (and (and (or (and x0 x6) (and x7 x6)) (and (not x0) (or x0 x4))) (and (or (and x7 x5) (or x4 x4)) (not (and x0 x5))))) (and (and (and (or (or x1 x6) (and x1 x4)) (not (and x2 x4))) (or (not (and x6 x6)) (and (not x3) (or x3 x1)))) (and (and (not (or x7 x6)) (not (not x4))) (or (not (not x7)) (or (not x3) (or x7 x5))))))) (not (not (and (or (and (and (and x0 x1) (or x3 x2)) (and (not x3) (not x2))) (not (not (or x6 x6)))) (or (or (and (and x3 x0) (not x2)) (or (and x7 x4) (not x2))) (not (and (not x4) (and x6 x6)))))))) (or (and (not (or (not (and (not (or x2 x4)) (and (and x1 x2) (and x1 x7)))) (not (not (and (and x2 x5) (or x5 x1)))))) (or (or (and (and (and (and x0 x1) (and x3 x5)) (and (and x0 x5) (not x6))) (or (or (or x7 x4) (not x5)) (and (and x0 x7) (and x5 x0)))) (and (not (not (and x5 x4))) (and (and (or x2 x4) (not x4)) (not (or x7 x3))))) (or (not (and (and (not x7) (not x3)) (not (or x2 x4)))) (and (not (or (and x4 x0) (not x1))) (and (and (not x1) (not x2)) (or (or x1 x4) (and x7 x1))))))) (or (and (and (or (and (or (or x1 x0) (and x0 x2)) (or (or x7 x5) (or x0 x4))) (and (or (and x1 x3) (and x4 x5)) (and (or x4 x0) (or x0 x3)))) (and (and (or (not x7) (and x4 x0)) (not (and x6 x3))) (and (and (and x3 x2) (not x1)) (not (and x3 x0))))) (not (not (not (and (not x6) (not x6)))))) (or (not (and (or (or (not x0) (and x5 x1)) (not (and x0 x3))) (or (not (and x7 x5)) (and (and x0 x1) (and x3 x3))))) (and (and (and (and (or x3 x3) (and x6 x2)) (not (not x0))) (or (and (not x4) (and x0 x7)) (and (not x7) (not x7)))) (or (not (not (not x5))) (not (and (not x5) (or x7 x0))))))))))) +(check-sat) +(push 1) +(assert (and (or (or (not (not (not x1))) (and (not (not x2)) (not (and x3 x2)))) (not (not (or (not x2) (and x5 x5))))) (and (not (and (or (or x1 x1) (not x3)) (and (or x0 x3) (not x2)))) (or (not (or (or x2 x3) (or x4 x1))) (or (and (not x6) (not x5)) (not (or x4 x1))))))) +(assert (and (not (not (and (not (or x5 x6)) (or (and x7 x0) (not x2))))) (or (not (not (and (not x5) (not x7)))) (or (and (and (not x3) (or x0 x6)) (or (and x2 x7) (or x5 x0))) (and (and (or x4 x3) (or x7 x6)) (not (and x7 x4))))))) +(assert (not x2)) +(assert (or (not (and (and (not (or (and (not (and (and x1 x6) (not x6))) (and (not (or x5 x5)) (not (and x2 x6)))) (and (and (not (not x0)) (and (and x5 x2) (or x5 x1))) (or (not (and x6 x3)) (not (or x1 x4)))))) (and (not (not (not (and (or x3 x4) (and x2 x7))))) (or (not (and (not (not x3)) (or (not x0) (not x2)))) (and (not (not (and x4 x1))) (and (or (not x2) (and x3 x3)) (not (or x7 x6))))))) (not (or (or (and (not (or (and x3 x6) (not x4))) (not (not (or x4 x2)))) (not (or (not (not x3)) (not (not x5))))) (or (not (not (not (or x7 x5)))) (or (or (or (and x5 x5) (and x0 x4)) (or (and x3 x2) (not x7))) (or (and (or x2 x6) (or x6 x0)) (and (and x6 x7) (and x3 x6))))))))) (and (and (or (and (or (and (not (and (or x2 x4) (not x5))) (and (and (and x3 x6) (and x6 x4)) (or (or x4 x2) (and x3 x1)))) (or (or (and (and x3 x7) (or x2 x3)) (or (or x7 x6) (or x1 x3))) (not (not (not x4))))) (or (and (or (or (and x6 x5) (and x5 x0)) (not (or x6 x1))) (not (and (or x0 x4) (or x4 x1)))) (not (not (or (or x5 x4) (not x4)))))) (and (or (or (not (or (not x2) (or x3 x7))) (or (or (not x3) (not x5)) (or (or x5 x1) (and x1 x2)))) (and (and (and (and x0 x2) (or x4 x3)) (or (and x7 x2) (or x1 x6))) (and (and (and x4 x3) (or x2 x1)) (or (not x6) (and x3 x0))))) (and (not (or (or (or x4 x7) (and x0 x2)) (or (and x1 x1) (and x2 x7)))) (not (and (or (not x6) (and x6 x7)) (not (not x5))))))) (or (or (not (or (or (or (or x3 x5) (or x0 x5)) (not (or x0 x5))) (or (or (and x7 x7) (or x2 x3)) (or (or x1 x7) (or x1 x5))))) (or (not (and (or (and x3 x6) (not x0)) (or (not x6) (not x0)))) (not (and (and (or x1 x0) (and x3 x2)) (not (and x4 x1)))))) (not (not (or (and (or (or x3 x3) (and x6 x1)) (and (or x1 x6) (and x4 x7))) (and (and (and x0 x6) (or x5 x2)) (not (and x6 x6)))))))) (or (or (not (or (not (not (and (or x4 x0) (and x5 x5)))) (and (and (and (or x3 x3) (and x0 x2)) (or (not x2) (not x1))) (or (or (not x1) (and x0 x2)) (not (not x2)))))) (and (or (or (not (not (not x4))) (and (or (not x5) (or x3 x7)) (and (or x2 x5) (and x2 x6)))) (not (not (not (or x1 x5))))) (and (not (not (not (and x7 x0)))) (and (not (not (not x0))) (or (or (and x4 x0) (not x2)) (or (and x7 x6) (not x5))))))) (not (and (or (not (not (not (and x4 x7)))) (or (not (not (or x5 x1))) (or (or (and x2 x6) (or x6 x7)) (or (not x5) (not x7))))) (not (not (not (and (not x6) (and x5 x5))))))))))) +(check-sat) +(pop 1) +(assert (not (not (not x3)))) +(check-sat) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(assert (or (or (and (not (not (not x0))) (not (and (not x4) (not x1)))) (and (and (or (and x3 x1) (not x1)) (and (not x3) (and x3 x4))) (and (or (or x1 x4) (and x3 x2)) (and (and x2 x4) (or x1 x4))))) (not (or (or (and (and x4 x1) (or x4 x2)) (and (or x0 x3) (not x2))) (not (or (or x0 x0) (and x0 x2))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (not (or (and (not (or (or (and (or (or x2 x0) (not x4)) (not (not x2))) (and (not (not x0)) (not (and x2 x1)))) (and (or (or (and x2 x2) (or x0 x4)) (or (and x0 x2) (or x3 x2))) (or (and (and x1 x3) (and x0 x4)) (or (or x0 x4) (and x4 x0)))))) (or (or (or (and (not (not x1)) (and (or x0 x3) (and x2 x4))) (and (not (and x2 x1)) (and (not x0) (and x1 x3)))) (and (not (and (or x3 x4) (and x4 x3))) (or (or (not x4) (not x2)) (and (not x1) (or x0 x3))))) (or (or (not (and (not x2) (and x4 x0))) (or (and (not x3) (and x2 x2)) (or (and x0 x2) (and x1 x3)))) (and (or (and (and x1 x4) (or x4 x4)) (not (not x0))) (not (not (not x0))))))) (and (not (and (or (not (and (not x2) (not x2))) (or (not (or x3 x4)) (not (or x4 x1)))) (not (and (not (not x4)) (and (and x4 x3) (and x0 x1)))))) (not (or (and (and (not (not x0)) (not (or x2 x1))) (not (and (or x1 x2) (or x0 x3)))) (or (or (or (not x1) (not x3)) (not (and x1 x2))) (and (or (and x2 x4) (or x3 x4)) (and (or x2 x0) (not x1)))))))))) +(assert (not (or (not (or (not (and (or (and (not (or x2 x1)) (and (and x3 x3) (and x0 x1))) (or (or (or x1 x4) (or x0 x0)) (not (and x4 x2)))) (and (not (or (and x0 x1) (not x4))) (and (and (not x2) (or x3 x1)) (and (or x3 x3) (and x0 x4)))))) (or (not (not (not (and (not x0) (not x4))))) (and (not (and (or (and x4 x0) (or x0 x2)) (or (not x0) (and x1 x2)))) (not (and (not (and x1 x1)) (not (and x1 x4)))))))) (not (and (and (not (and (not (or (not x0) (and x1 x2))) (not (not (and x1 x1))))) (or (and (not (not (and x3 x0))) (not (and (and x2 x2) (or x1 x0)))) (and (and (or (not x1) (or x2 x3)) (not (or x2 x1))) (or (not (and x0 x2)) (or (or x3 x1) (and x0 x4)))))) (or (and (or (and (not (or x2 x3)) (not (not x1))) (and (and (and x0 x1) (not x4)) (or (or x3 x1) (or x0 x1)))) (and (or (and (and x0 x0) (and x0 x4)) (or (or x4 x0) (and x2 x2))) (or (and (and x0 x3) (and x1 x3)) (not (and x1 x1))))) (not (and (not (not (not x1))) (or (not (not x4)) (or (and x3 x2) (and x0 x3))))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (or (or (and x1 x2) (and x1 x2)) (and (or x3 x4) (and x1 x3))) (and (and (not x1) (or x4 x1)) (or (or x2 x2) (not x4))))) +(assert (or (or (or (or (not (and (not (and (not (or x2 x0)) (not (or x1 x3)))) (not (not (and (or x4 x0) (not x1)))))) (not (not (or (not (or (not x3) (not x2))) (and (not (or x2 x1)) (and (not x2) (or x2 x2))))))) (not (not (and (and (or (or (not x0) (not x1)) (or (or x4 x3) (or x4 x2))) (and (or (and x0 x2) (and x4 x3)) (or (or x2 x4) (and x1 x4)))) (and (or (not (not x4)) (and (and x4 x4) (not x0))) (and (and (or x0 x2) (and x1 x1)) (and (and x2 x3) (or x2 x3)))))))) (or (and (and (and (or (not (not (not x4))) (or (and (not x4) (and x4 x4)) (or (and x2 x3) (and x4 x4)))) (or (or (and (or x0 x2) (or x3 x4)) (or (not x0) (or x1 x1))) (not (and (and x0 x1) (not x3))))) (and (not (not (and (not x0) (or x3 x4)))) (and (or (or (and x1 x3) (not x1)) (and (or x0 x0) (or x3 x1))) (or (and (or x2 x1) (not x2)) (not (not x3)))))) (or (or (not (or (or (and x3 x1) (and x4 x4)) (not (and x1 x1)))) (and (or (and (and x1 x0) (not x3)) (not (not x4))) (or (or (not x3) (and x2 x1)) (and (not x2) (not x3))))) (not (or (not (or (or x2 x1) (and x4 x4))) (or (and (and x2 x3) (and x1 x4)) (not (or x0 x2))))))) (and (and (not (and (not (and (or x0 x0) (or x4 x0))) (or (or (not x1) (or x2 x2)) (or (and x0 x2) (or x0 x4))))) (not (not (not (and (not x4) (not x4)))))) (or (and (and (and (and (and x4 x0) (not x3)) (not (not x1))) (not (not (and x2 x4)))) (or (not (not (and x3 x0))) (not (and (not x3) (not x3))))) (and (or (and (not (not x4)) (or (or x1 x0) (and x0 x1))) (and (not (or x0 x1)) (and (and x2 x4) (or x1 x4)))) (or (and (not (not x1)) (not (or x1 x1))) (not (and (not x3) (or x0 x3))))))))) (not (and (not (or (or (or (not (and (or x2 x2) (and x2 x3))) (not (and (or x1 x4) (and x1 x1)))) (and (and (and (or x1 x2) (and x1 x2)) (or (and x4 x2) (or x4 x3))) (and (not (not x3)) (not (or x3 x0))))) (not (not (and (or (and x4 x4) (not x3)) (and (or x1 x1) (not x2))))))) (or (not (not (not (not (or (not x4) (and x0 x2)))))) (or (not (or (not (and (or x1 x0) (and x2 x0))) (and (and (not x3) (or x2 x4)) (not (not x0))))) (or (not (and (not (not x3)) (not (and x0 x4)))) (and (or (or (and x4 x1) (and x4 x2)) (or (or x0 x3) (or x3 x2))) (or (or (not x2) (or x2 x4)) (not (not x2))))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (or (and (or (and (or (not (or (and (or x1 x4) (and x4 x1)) (and (not x2) (not x3)))) (and (and (not (or x4 x1)) (or (not x3) (and x2 x3))) (and (or (and x3 x3) (and x0 x2)) (or (and x1 x0) (or x2 x4))))) (not (not (or (or (or x2 x2) (and x3 x3)) (not (not x2)))))) (and (and (or (or (not (not x3)) (or (and x0 x0) (and x1 x1))) (or (and (and x3 x2) (and x0 x1)) (and (and x1 x2) (or x1 x4)))) (not (or (or (and x2 x2) (and x3 x2)) (and (not x2) (not x1))))) (and (not (and (or (and x1 x2) (not x1)) (and (and x1 x1) (or x4 x3)))) (and (or (not (and x3 x3)) (not (not x3))) (or (and (and x0 x4) (not x1)) (or (and x1 x3) (not x0))))))) (not (and (and (or (not (not (or x2 x4))) (not (or (not x3) (and x4 x2)))) (or (or (and (or x2 x0) (and x0 x4)) (not (or x2 x4))) (or (or (or x3 x4) (not x4)) (and (or x3 x1) (or x1 x1))))) (and (and (or (not (or x0 x2)) (or (not x0) (and x3 x4))) (and (not (not x1)) (not (or x1 x0)))) (not (not (or (not x4) (not x0)))))))) (or (not (not (or (and (or (or (and x1 x4) (not x0)) (not (not x0))) (and (and (or x3 x1) (or x0 x4)) (or (and x0 x1) (and x2 x3)))) (not (not (and (not x3) (or x4 x3))))))) (not (and (or (not (and (not (and x0 x3)) (not (not x3)))) (and (or (and (or x0 x1) (and x1 x4)) (not (and x2 x4))) (or (and (not x4) (and x4 x2)) (or (or x2 x1) (not x2))))) (and (or (and (or (not x3) (and x4 x1)) (not (not x0))) (and (and (and x1 x4) (and x2 x1)) (and (not x3) (and x0 x2)))) (not (not (or (not x3) (and x4 x0))))))))) (and (or (or (not (not (and (and (not (or x3 x3)) (or (not x2) (not x0))) (and (or (and x4 x4) (and x3 x3)) (not (and x0 x1)))))) (or (not (or (and (and (and x4 x1) (not x2)) (or (and x2 x4) (not x4))) (and (and (not x1) (not x2)) (or (or x4 x0) (not x4))))) (or (and (or (or (not x4) (not x3)) (not (not x4))) (or (and (or x2 x3) (and x2 x4)) (or (not x1) (and x1 x3)))) (not (and (and (or x2 x3) (and x3 x1)) (not (and x0 x3))))))) (not (and (not (and (and (or (not x0) (or x0 x4)) (not (and x3 x0))) (not (or (and x2 x3) (not x3))))) (and (not (not (or (not x3) (and x2 x1)))) (or (not (not (not x2))) (or (and (and x2 x2) (or x1 x1)) (and (and x2 x4) (not x2)))))))) (or (not (and (not (and (or (or (and x1 x1) (not x4)) (and (not x4) (and x2 x3))) (not (or (not x4) (and x1 x2))))) (or (not (and (and (and x4 x2) (and x1 x0)) (or (and x3 x3) (not x0)))) (not (or (and (and x1 x2) (not x1)) (or (and x1 x1) (not x0))))))) (and (not (or (or (and (not (not x1)) (and (or x1 x1) (not x0))) (and (not (and x2 x2)) (or (or x1 x2) (not x2)))) (or (or (or (and x4 x3) (not x3)) (and (and x2 x3) (or x4 x2))) (not (not (or x2 x0)))))) (not (and (or (or (or (not x0) (not x0)) (or (or x4 x0) (and x4 x1))) (not (not (not x0)))) (or (and (or (and x3 x1) (or x4 x0)) (not (and x1 x1))) (not (and (and x2 x3) (and x4 x3))))))))))) +(assert (or (not (not (and (not (not (or (and (or (and x3 x4) (not x4)) (or (and x2 x2) (not x0))) (or (not (or x3 x4)) (or (and x4 x1) (or x0 x2)))))) (and (not (and (or (not (not x0)) (not (or x3 x1))) (not (and (or x4 x2) (or x4 x2))))) (and (and (or (and (or x1 x2) (not x2)) (or (not x1) (and x1 x2))) (not (and (and x2 x1) (or x1 x4)))) (or (or (or (not x3) (or x4 x0)) (or (not x0) (and x3 x3))) (not (or (and x0 x1) (or x4 x0))))))))) (or (and (and (not (or (and (not (not (and x1 x2))) (and (not (not x3)) (and (and x4 x0) (or x4 x3)))) (or (and (or (or x3 x4) (and x2 x4)) (and (and x2 x2) (or x0 x2))) (not (and (and x0 x1) (and x2 x1)))))) (or (and (not (not (not (not x2)))) (and (and (or (not x2) (and x4 x2)) (and (and x2 x3) (or x0 x4))) (and (or (or x0 x2) (not x0)) (not (and x2 x2))))) (or (and (and (or (or x3 x0) (and x2 x3)) (or (not x2) (and x3 x1))) (or (not (and x2 x0)) (and (not x2) (not x1)))) (not (and (or (and x0 x0) (or x2 x1)) (and (not x4) (or x2 x4))))))) (or (or (or (not (not (and (not x4) (or x1 x1)))) (not (not (not (and x3 x3))))) (or (not (and (and (and x4 x1) (not x4)) (not (not x0)))) (or (or (not (and x4 x1)) (and (not x1) (or x0 x4))) (not (not (and x4 x2)))))) (or (not (not (or (or (or x2 x2) (and x2 x3)) (or (and x3 x4) (not x0))))) (or (not (and (and (not x0) (or x1 x4)) (not (not x3)))) (and (or (and (or x1 x0) (not x1)) (not (or x4 x2))) (or (not (and x0 x1)) (or (and x0 x0) (or x3 x1)))))))) (not (or (and (and (or (or (not (not x4)) (and (or x0 x1) (or x4 x3))) (and (or (not x4) (and x4 x4)) (not (and x2 x0)))) (not (or (not (or x4 x2)) (and (not x1) (or x0 x4))))) (or (or (and (or (not x1) (and x3 x0)) (or (not x1) (and x0 x1))) (or (not (not x4)) (and (and x4 x3) (and x1 x4)))) (or (not (not (or x2 x0))) (and (and (and x4 x2) (not x0)) (and (or x1 x1) (and x2 x4)))))) (or (or (not (not (not (or x2 x4)))) (not (not (or (or x3 x3) (and x1 x1))))) (or (or (and (and (and x2 x4) (and x3 x3)) (and (and x0 x4) (not x1))) (not (not (not x3)))) (and (or (or (and x1 x0) (and x1 x4)) (and (and x4 x0) (or x0 x3))) (or (and (or x1 x0) (and x1 x2)) (not (not x3))))))))))) +(check-sat) +(push 1) +(assert (or (or (and (and (and (and (or (or (not (and x4 x4)) (and (and x4 x0) (not x3))) (and (not (or x4 x0)) (not (or x0 x0)))) (not (or (not (and x3 x0)) (or (and x4 x0) (and x1 x3))))) (or (not (not (not (or x4 x1)))) (not (not (not (not x3)))))) (not (not (not (or (and (not x3) (or x1 x3)) (and (and x2 x3) (or x2 x2))))))) (not (not (or (not (and (not (or x4 x1)) (and (and x1 x4) (and x2 x2)))) (and (not (not (or x3 x2))) (not (not (not x4)))))))) (or (or (and (or (not (not (not (or x1 x1)))) (not (not (not (or x0 x1))))) (not (not (and (not (not x3)) (and (not x2) (and x4 x3)))))) (and (not (or (and (not (and x1 x0)) (and (and x3 x1) (or x1 x0))) (or (not (and x3 x2)) (or (or x1 x4) (and x2 x1))))) (not (not (or (and (and x2 x0) (not x0)) (and (and x2 x0) (and x0 x4))))))) (and (and (not (and (and (or (or x2 x4) (and x0 x3)) (not (or x1 x2))) (not (and (and x1 x1) (or x4 x3))))) (and (not (or (not (or x2 x3)) (or (or x2 x0) (and x3 x4)))) (not (not (or (and x2 x0) (not x4)))))) (or (not (and (not (not (or x0 x0))) (not (not (or x1 x3))))) (and (not (and (and (and x3 x4) (or x1 x0)) (or (and x2 x4) (not x2)))) (not (not (and (and x0 x1) (and x2 x4))))))))) (not (and (or (not (and (and (and (not (or x4 x2)) (and (not x0) (not x0))) (not (or (or x0 x1) (not x2)))) (or (or (and (and x3 x1) (or x4 x3)) (not (and x0 x2))) (or (and (and x1 x0) (not x0)) (or (not x2) (and x3 x3)))))) (not (and (and (and (or (and x3 x4) (and x3 x3)) (not (or x3 x4))) (not (not (and x3 x0)))) (or (and (not (or x4 x4)) (not (not x3))) (and (not (and x4 x1)) (or (and x2 x3) (and x0 x1))))))) (or (and (and (not (or (or (not x3) (not x4)) (not (or x1 x0)))) (and (or (or (and x1 x3) (and x1 x4)) (not (or x3 x1))) (and (not (and x0 x3)) (not (or x1 x1))))) (not (or (not (and (or x0 x0) (and x2 x2))) (not (or (not x4) (not x4)))))) (or (or (and (and (and (and x1 x2) (or x1 x0)) (or (or x1 x2) (or x2 x2))) (not (and (not x0) (or x1 x3)))) (not (or (or (or x0 x1) (or x4 x1)) (not (not x1))))) (not (or (not (and (not x3) (not x3))) (and (or (and x0 x0) (or x0 x1)) (or (and x1 x1) (not x4))))))))))) +(assert (or (and (not (not (or (not (and x1 x3)) (not (not x3))))) (not (not (or (and (or x4 x0) (not x0)) (and (and x0 x0) (and x4 x1)))))) (not (and (and (not (and (or x2 x0) (or x0 x2))) (or (not (not x3)) (and (and x2 x1) (and x1 x3)))) (not (and (not (or x4 x0)) (or (not x2) (not x1)))))))) +(assert (or (and (not (not (and (and (and (not x0) (and x2 x3)) (or (or x1 x0) (and x4 x2))) (or (and (or x1 x0) (and x2 x4)) (or (and x0 x3) (not x4)))))) (or (and (not (not (and (not x2) (not x4)))) (or (or (or (and x0 x2) (and x4 x4)) (not (or x2 x4))) (and (not (and x0 x4)) (or (or x0 x2) (or x0 x2))))) (or (and (not (or (or x1 x1) (and x2 x0))) (not (and (not x2) (or x2 x2)))) (or (or (not (and x4 x4)) (or (and x0 x3) (not x1))) (and (not (not x4)) (or (or x0 x3) (not x1))))))) (and (or (and (or (or (and (or x3 x4) (or x2 x2)) (not (and x3 x0))) (or (not (and x2 x2)) (or (or x2 x1) (or x1 x1)))) (or (and (and (not x4) (not x1)) (or (and x1 x3) (and x3 x2))) (and (or (not x3) (or x2 x1)) (not (and x3 x2))))) (not (and (or (or (or x2 x3) (not x2)) (and (not x1) (not x2))) (or (and (or x3 x1) (and x3 x2)) (and (or x4 x2) (or x0 x4)))))) (and (or (and (or (not (and x4 x2)) (or (and x1 x3) (and x2 x3))) (or (not (and x0 x1)) (not (or x1 x2)))) (and (not (or (not x2) (or x3 x2))) (and (and (and x3 x3) (not x2)) (not (and x3 x3))))) (not (and (not (or (not x4) (not x3))) (or (or (and x1 x1) (not x0)) (and (not x0) (and x4 x3))))))))) +(assert (or (and (or (or (and x2 x2) (or x1 x2)) (or (or x2 x3) (not x0))) (not (not (not x3)))) (or (and (and (and x3 x4) (or x4 x4)) (and (or x0 x2) (and x2 x3))) (and (or (and x4 x4) (and x2 x1)) (or (not x3) (or x4 x4)))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(assert (or (not (and (or (and (and (or (or (or (and x3 x6) (not x8)) (or (or x3 x0) (or x5 x8))) (and (and (or x0 x5) (not x0)) (not (not x4)))) (not (and (and (or x8 x3) (and x6 x0)) (or (and x7 x3) (and x5 x0))))) (not (not (and (and (and x2 x5) (not x0)) (not (not x1)))))) (not (not (or (not (or (and x3 x3) (not x8))) (and (not (or x0 x1)) (or (not x7) (and x4 x1))))))) (not (not (or (not (not (or (not x0) (or x3 x3)))) (not (not (or (not x6) (and x6 x0))))))))) (or (not (and (and (or (not (and (or (and x2 x1) (or x2 x7)) (and (and x7 x5) (or x5 x0)))) (and (or (not (and x7 x8)) (and (not x3) (or x6 x6))) (and (and (or x7 x5) (or x7 x5)) (not (not x7))))) (and (or (not (or (not x6) (or x0 x5))) (or (or (or x1 x3) (or x7 x4)) (or (and x1 x2) (not x8)))) (or (not (or (and x1 x6) (and x6 x7))) (and (not (and x2 x5)) (not (or x2 x6)))))) (or (or (not (or (or (or x2 x0) (and x3 x2)) (and (or x1 x3) (or x6 x4)))) (and (not (and (or x1 x7) (or x1 x2))) (not (not (not x0))))) (not (not (not (and (or x0 x0) (or x5 x2)))))))) (and (and (or (not (not (not (or (and x0 x2) (or x4 x2))))) (or (and (or (or (and x5 x8) (and x3 x1)) (not (not x2))) (or (or (and x6 x6) (not x8)) (and (not x5) (or x2 x4)))) (or (or (not (not x5)) (not (and x6 x5))) (or (and (and x2 x4) (and x5 x1)) (or (not x7) (not x6)))))) (not (and (not (or (and (not x1) (not x3)) (not (or x6 x2)))) (or (not (or (or x0 x4) (and x2 x5))) (or (or (and x4 x2) (and x1 x1)) (not (or x7 x8))))))) (and (or (not (or (not (not (not x2))) (not (and (or x3 x0) (and x3 x2))))) (or (not (and (and (and x0 x2) (and x8 x1)) (or (and x5 x7) (or x1 x2)))) (or (and (not (or x4 x3)) (or (or x6 x1) (and x1 x2))) (and (not (or x6 x1)) (and (or x1 x6) (or x3 x6)))))) (and (not (not (or (and (not x0) (or x5 x1)) (not (not x0))))) (or (or (and (not (not x4)) (and (not x1) (not x0))) (or (or (not x3) (and x5 x0)) (or (not x3) (and x1 x6)))) (not (not (or (and x7 x2) (not x5))))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (or x1 x2)) (and (or x3 x3) (or x1 x0)))) +(check-sat) +(pop 1) +(assert (or (not (and (and x1 x3) (not x4))) (or (not (or x0 x0)) (or (and x1 x8) (not x0))))) +(assert (or (not x7) (and x1 x7))) +(assert (and (or (not (or (not x4) (or x3 x6))) (and (and (and x1 x1) (not x2)) (not (and x8 x5)))) (and (and (or (not x7) (and x0 x8)) (and (or x2 x5) (or x5 x4))) (and (or (and x5 x7) (not x6)) (or (and x5 x2) (or x8 x2)))))) +(assert (or (and (or (or (or (not x4) (or x6 x7)) (not (or x3 x4))) (and (and (or x8 x3) (not x7)) (and (not x5) (or x8 x3)))) (or (and (or (or x3 x2) (and x0 x2)) (and (not x7) (and x8 x6))) (and (not (or x7 x7)) (or (or x8 x2) (not x6))))) (not (not (and (and (and x7 x7) (not x0)) (and (not x7) (not x2))))))) +(check-sat) +(push 1) +(assert (and x0 x5)) +(check-sat) +(pop 1) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (or (not (and (not (or (or (and (not (and x0 x3)) (not (not x1))) (or (not (and x4 x4)) (or (not x4) (not x4)))) (or (not (or (or x4 x0) (and x4 x2))) (not (or (and x4 x0) (or x1 x3)))))) (not (or (and (or (or (or x4 x2) (and x3 x2)) (or (not x3) (or x3 x4))) (or (not (or x2 x2)) (and (or x1 x1) (not x4)))) (or (and (not (or x0 x4)) (and (or x0 x3) (not x0))) (not (and (and x1 x2) (and x1 x4)))))))) (not (and (not (and (or (and (not (or x0 x4)) (or (and x1 x4) (and x3 x3))) (or (or (not x3) (or x1 x1)) (not (not x4)))) (not (and (and (and x2 x4) (and x2 x4)) (not (not x4)))))) (and (and (not (not (or (not x4) (and x4 x0)))) (not (and (not (and x0 x0)) (or (not x4) (or x3 x2))))) (not (not (and (and (not x2) (and x4 x4)) (not (and x1 x2))))))))) (and (or (and (not (and (not (or (or (and x1 x2) (not x0)) (or (not x4) (and x3 x0)))) (or (not (or (or x1 x3) (not x0))) (and (or (or x3 x0) (and x2 x0)) (not (not x0)))))) (or (and (and (and (and (not x0) (and x0 x1)) (and (not x1) (or x1 x3))) (not (not (or x1 x1)))) (or (not (or (or x2 x3) (or x2 x1))) (or (not (not x4)) (and (and x0 x4) (not x0))))) (or (and (or (not (not x1)) (or (not x2) (or x1 x4))) (or (or (not x3) (not x4)) (not (and x2 x2)))) (or (and (or (and x3 x1) (and x1 x1)) (not (and x4 x2))) (and (or (not x2) (and x4 x3)) (and (not x2) (or x0 x2))))))) (and (or (and (or (or (and (not x1) (or x0 x4)) (not (not x3))) (not (or (or x3 x1) (and x1 x0)))) (or (and (or (and x3 x3) (not x3)) (or (and x0 x2) (not x4))) (and (not (not x2)) (and (and x3 x2) (and x4 x3))))) (and (not (not (or (not x2) (and x0 x3)))) (not (and (and (not x3) (not x4)) (not (not x4)))))) (or (not (or (not (not (not x2))) (and (and (not x0) (and x3 x4)) (or (not x4) (and x0 x1))))) (not (or (and (or (and x2 x1) (or x3 x2)) (not (and x1 x4))) (and (not (or x0 x4)) (not (not x1)))))))) (or (and (and (not (or (or (and (and x3 x0) (not x2)) (and (or x0 x4) (and x3 x2))) (and (or (and x1 x3) (and x2 x0)) (or (not x0) (or x0 x3))))) (not (not (and (or (and x4 x3) (or x1 x0)) (not (and x2 x3)))))) (not (or (not (and (and (and x3 x4) (or x3 x4)) (or (or x1 x2) (and x1 x4)))) (not (not (or (and x2 x2) (and x4 x4))))))) (or (or (not (or (or (or (or x2 x0) (not x2)) (or (not x0) (or x4 x4))) (or (or (and x2 x0) (or x1 x1)) (and (or x3 x0) (not x0))))) (or (or (and (not (not x3)) (not (and x3 x4))) (not (and (not x0) (not x0)))) (and (or (or (or x2 x3) (and x3 x0)) (or (or x0 x3) (or x2 x2))) (not (not (and x3 x0)))))) (or (or (not (or (not (not x4)) (and (and x4 x0) (and x2 x2)))) (or (and (or (or x4 x2) (and x0 x3)) (and (and x0 x3) (not x0))) (not (and (or x3 x0) (and x0 x4))))) (and (or (and (or (and x2 x2) (and x0 x2)) (not (not x1))) (not (or (and x1 x1) (and x1 x2)))) (and (not (not (not x2))) (or (or (not x1) (and x0 x4)) (or (not x0) (not x0))))))))))) +(assert (or (or (or (and x2 x1) (and x4 x4)) (or (or x1 x4) (and x2 x3))) (not (and (and x3 x4) (not x0))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (not (and (not (and (not (or (or x3 x0) (and x0 x2))) (not (and (and x2 x0) (not x3))))) (and (or (or (not (and x3 x1)) (not (and x4 x4))) (or (or (or x0 x3) (or x4 x4)) (not (not x3)))) (not (or (not (not x0)) (and (or x1 x0) (and x3 x2))))))) (not (and (and (and (or (or (or x2 x1) (and x0 x1)) (and (or x3 x0) (or x0 x0))) (or (and (and x3 x1) (or x3 x4)) (not (not x4)))) (not (and (or (and x2 x1) (and x4 x0)) (not (not x0))))) (and (and (or (or (and x3 x3) (or x1 x4)) (and (and x2 x3) (not x1))) (not (and (or x4 x2) (or x4 x4)))) (not (not (or (and x1 x1) (and x4 x3))))))))) +(assert (not (not (not (not (and (or (not (or (and (not x4) (not x2)) (and (not x4) (not x1)))) (not (and (and (and x2 x2) (and x4 x3)) (not (and x1 x0))))) (not (or (and (not (and x3 x2)) (not (not x2))) (not (not (not x2))))))))))) +(check-sat) +(push 1) +(assert (or (or (or (or (not x4) (not x1)) (not (not x1))) (and (and (and x4 x1) (and x4 x4)) (and (and x4 x0) (or x0 x2)))) (not (and (not (and x3 x0)) (and (not x2) (or x1 x0)))))) +(check-sat) +(pop 1) +(assert (not (or (not (not x3)) (or (not x2) (not x4))))) +(assert (and (or x3 x4) (and x4 x0))) +(assert (and (not (not (not (or (or (or (and (and (or x2 x3) (or x3 x1)) (and (or x0 x3) (and x4 x4))) (and (not (and x2 x4)) (or (and x4 x0) (or x4 x3)))) (not (or (and (and x0 x4) (not x4)) (not (or x3 x4))))) (and (and (or (not (and x1 x4)) (or (not x1) (and x4 x2))) (not (or (or x1 x2) (and x4 x3)))) (not (or (or (not x2) (not x4)) (and (or x1 x3) (not x3))))))))) (not (or (and (not (and (and (and (not (and x3 x3)) (not (and x1 x1))) (not (or (not x4) (or x2 x1)))) (and (not (or (not x4) (and x4 x2))) (or (or (and x1 x2) (not x4)) (and (or x3 x4) (not x0)))))) (and (or (or (or (or (or x3 x2) (or x1 x3)) (or (not x4) (or x1 x4))) (or (not (and x1 x0)) (and (and x4 x3) (and x0 x0)))) (and (or (not (not x0)) (or (or x0 x3) (or x4 x4))) (and (not (or x2 x2)) (not (and x2 x4))))) (or (not (and (or (and x1 x1) (or x1 x1)) (not (or x0 x0)))) (and (not (and (or x1 x3) (or x3 x3))) (or (and (or x0 x1) (not x2)) (or (or x3 x0) (or x3 x1))))))) (not (not (or (and (not (or (or x2 x2) (or x0 x3))) (or (and (and x4 x3) (not x4)) (or (or x0 x4) (and x3 x0)))) (and (or (and (or x1 x0) (or x0 x1)) (not (and x3 x4))) (and (or (or x2 x2) (or x1 x3)) (not (or x0 x1))))))))))) +(assert (or (not (and (and (or (and x3 x4) (not x3)) (not (or x1 x0))) (and (and (or x3 x2) (or x2 x1)) (and (and x0 x1) (and x0 x2))))) (not (not (or (not (not x1)) (or (or x1 x3) (or x1 x4))))))) +(check-sat) +(pop 1) +(assert (not (or x1 x2))) +(assert (or (and (or (or x2 x0) (not x4)) (or (not x4) (or x2 x2))) (not (not (or x2 x3))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (or (and (or (and (and (or (and (and (and x6 x1) (not x7)) (not (and x5 x9))) (or (or (and x8 x7) (or x5 x4)) (and (and x3 x2) (and x2 x9)))) (and (or (not (or x8 x3)) (and (or x1 x0) (not x9))) (or (or (and x7 x1) (not x5)) (not (and x1 x8))))) (not (and (and (or (and x4 x2) (or x5 x5)) (and (and x4 x6) (not x8))) (and (or (or x7 x4) (and x3 x1)) (or (and x8 x7) (or x9 x8)))))) (or (or (or (and (not (not x6)) (or (and x1 x5) (or x5 x2))) (or (not (or x3 x1)) (and (not x3) (or x0 x9)))) (and (or (not (or x0 x7)) (or (or x8 x3) (or x5 x9))) (or (or (not x3) (and x0 x5)) (and (or x7 x8) (or x6 x7))))) (not (not (not (and (and x0 x3) (and x1 x0))))))) (and (and (or (and (and (not (not x0)) (or (or x3 x4) (and x0 x9))) (not (not (and x1 x5)))) (not (not (or (and x7 x5) (not x0))))) (or (not (and (or (or x0 x9) (not x8)) (not (and x4 x5)))) (not (or (and (and x9 x3) (not x8)) (or (or x4 x9) (and x9 x7)))))) (and (or (not (and (not (not x8)) (or (not x8) (or x2 x1)))) (or (or (not (not x6)) (and (and x5 x2) (or x3 x8))) (not (and (or x7 x7) (or x5 x2))))) (or (or (and (not (not x2)) (and (or x2 x9) (or x8 x5))) (or (or (and x3 x4) (and x7 x5)) (and (not x1) (not x6)))) (or (or (and (not x4) (and x3 x3)) (and (not x5) (or x7 x9))) (not (and (not x8) (and x5 x0)))))))) (or (not (or (or (not (and (or (not x5) (and x0 x6)) (not (not x0)))) (and (not (or (or x5 x1) (or x4 x0))) (and (not (or x4 x9)) (or (or x4 x1) (or x7 x8))))) (or (or (not (or (and x2 x3) (and x1 x4))) (not (and (and x2 x3) (or x5 x7)))) (not (not (or (or x7 x9) (and x3 x5))))))) (not (not (or (not (or (or (not x0) (not x9)) (or (or x3 x9) (or x9 x1)))) (or (and (not (not x1)) (and (and x9 x3) (or x0 x8))) (or (and (and x3 x7) (or x6 x8)) (not (or x9 x1)))))))))) +(check-sat) +(push 1) +(assert (and (not (or (not (or (not (not x3)) (and (and x2 x3) (and x9 x3)))) (or (or (or (and x5 x8) (and x4 x6)) (not (or x7 x3))) (not (and (or x8 x6) (and x4 x7)))))) (or (or (not (not (or (and x5 x1) (or x8 x3)))) (and (not (and (not x5) (not x1))) (or (not (not x0)) (not (not x6))))) (or (and (not (and (or x1 x2) (and x5 x4))) (and (not (and x3 x9)) (or (not x9) (not x7)))) (and (not (and (or x6 x2) (or x9 x9))) (or (and (not x9) (or x4 x4)) (not (and x4 x7)))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (not (and (not (and (or (not (not x7)) (or (and x6 x1) (not x6))) (or (and (or x4 x3) (not x3)) (or (or x4 x1) (not x4))))) (not (or (and (not (not x4)) (not (and x5 x6))) (not (and (or x2 x1) (or x3 x7)))))))))) +(check-sat) +(push 1) +(assert (not (and (not (not x1)) (or (or x8 x7) (and x1 x2))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (or x6 x2))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (and (not (and (and x3 x6) (and x6 x9))) (not (or (and x1 x6) (and x5 x1)))) (and (not (or (and x2 x8) (not x4))) (or (not (not x3)) (or (not x3) (or x1 x7)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (or (not (and (not (not (and (not (not x5)) (or (not x3) (or x1 x7))))) (not (or (or (or (and x8 x9) (or x6 x8)) (or (not x6) (not x2))) (not (and (not x8) (or x3 x9))))))) (or (and (and (and (and (and (and x7 x9) (and x3 x2)) (not (and x1 x4))) (and (not (not x1)) (and (or x8 x3) (or x3 x4)))) (and (and (or (and x4 x6) (and x9 x2)) (not (or x9 x1))) (not (and (or x6 x8) (not x2))))) (and (and (or (and (or x1 x2) (and x4 x8)) (or (or x7 x4) (or x3 x1))) (and (not (not x2)) (or (and x3 x0) (not x9)))) (not (not (not (not x1)))))) (and (or (not (not (or (or x2 x9) (or x8 x8)))) (or (or (not (and x5 x2)) (not (or x4 x5))) (and (not (or x6 x9)) (not (not x7))))) (not (and (not (not (or x5 x4))) (and (or (and x1 x7) (or x2 x2)) (not (not x9))))))))))) +(assert (not (or (and (or (or x6 x2) (and x9 x1)) (and (not x3) (and x8 x2))) (or (and (or x0 x0) (not x7)) (and (not x1) (and x7 x1)))))) +(check-sat) +(pop 1) +(assert (and (or (not (or (or (or (not (not (and x9 x8))) (and (not (and x6 x4)) (and (or x6 x2) (and x4 x2)))) (and (or (and (and x1 x4) (and x1 x8)) (and (or x6 x0) (or x8 x6))) (or (and (not x8) (and x7 x6)) (or (not x5) (not x7))))) (and (or (or (not (or x5 x5)) (and (and x3 x8) (not x9))) (and (or (or x6 x6) (or x0 x6)) (or (and x5 x1) (not x9)))) (or (and (or (and x5 x6) (not x9)) (not (not x6))) (or (not (and x9 x3)) (not (not x1))))))) (and (and (or (and (and (and (and x6 x3) (or x5 x5)) (or (and x7 x8) (and x3 x6))) (and (and (not x2) (not x7)) (not (and x2 x2)))) (or (not (and (not x5) (not x5))) (and (and (not x7) (and x8 x2)) (not (and x9 x1))))) (or (not (or (and (not x9) (not x0)) (and (not x8) (and x8 x5)))) (not (not (not (not x5)))))) (or (not (or (or (or (not x4) (and x1 x3)) (or (and x6 x1) (not x5))) (not (not (not x4))))) (and (and (or (not (or x9 x8)) (or (not x0) (and x9 x5))) (and (not (not x4)) (not (or x5 x8)))) (and (and (or (and x2 x1) (not x3)) (and (and x5 x6) (not x8))) (not (or (not x1) (not x8)))))))) (and (or (and (and (or (or (and (or x1 x5) (not x3)) (and (not x9) (not x3))) (and (and (or x1 x0) (or x2 x8)) (or (not x7) (and x0 x7)))) (or (or (and (and x1 x7) (or x4 x1)) (and (or x4 x9) (and x3 x9))) (not (and (not x8) (and x4 x2))))) (and (or (and (or (or x9 x5) (not x7)) (or (or x8 x9) (or x6 x4))) (and (not (not x1)) (or (and x7 x3) (or x0 x7)))) (or (or (and (not x6) (not x2)) (and (not x1) (and x8 x0))) (not (or (and x1 x8) (and x7 x3)))))) (and (and (or (and (or (or x6 x3) (not x5)) (not (not x9))) (and (or (or x5 x0) (and x8 x5)) (and (and x7 x0) (and x0 x9)))) (not (or (and (and x9 x1) (and x6 x7)) (and (or x4 x3) (or x7 x4))))) (and (or (not (and (or x5 x4) (or x1 x4))) (not (and (or x3 x1) (or x2 x7)))) (not (and (or (or x0 x6) (not x4)) (and (or x0 x0) (not x1))))))) (and (not (and (not (not (and (not x9) (and x2 x1)))) (and (not (or (or x0 x1) (not x4))) (not (or (not x1) (not x1)))))) (not (or (not (or (not (or x4 x6)) (not (not x4)))) (and (or (and (not x7) (not x3)) (or (not x4) (or x3 x6))) (and (and (and x9 x9) (and x2 x2)) (not (or x8 x4)))))))))) +(assert (and (and (or x9 x9) (or x2 x7)) (and (and x0 x3) (and x5 x2)))) +(assert (and (and (or (or x2 x2) (or x5 x2)) (and (or x6 x3) (or x1 x8))) (or (not (or x6 x4)) (or (or x2 x7) (or x4 x4))))) +(check-sat) +(push 1) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (and x7 x7))) +(check-sat) +(push 1) +(assert (or (or x0 x1) (not x7))) +(assert (not (and x6 x9))) +(assert (and (and (not (or x7 x5)) (or (or x3 x8) (or x5 x8))) (or (or (or x1 x5) (and x3 x6)) (or (and x2 x5) (or x1 x1))))) +(assert (or (not (or (not (not (not x9))) (and (or (and x2 x6) (and x2 x4)) (not (or x8 x2))))) (not (or (and (and (not x2) (not x3)) (and (or x0 x0) (and x7 x5))) (not (not (or x1 x9))))))) +(assert (or (or (not (or (and (not (and (or (or x6 x6) (and x0 x2)) (or (not x5) (not x3)))) (not (and (or (and x1 x2) (not x1)) (not (not x3))))) (or (not (not (or (or x9 x0) (not x6)))) (and (or (and (and x2 x6) (not x4)) (not (not x9))) (not (or (not x7) (or x4 x9))))))) (and (not (and (and (or (or (and x1 x2) (and x1 x5)) (and (not x7) (or x5 x1))) (or (not (and x0 x1)) (or (not x6) (not x1)))) (and (or (not (not x3)) (or (not x1) (not x2))) (or (and (and x4 x6) (not x4)) (and (or x1 x6) (or x2 x3)))))) (and (and (and (or (not (or x9 x9)) (not (or x7 x3))) (or (not (and x5 x3)) (not (not x8)))) (not (or (or (not x1) (or x4 x9)) (not (and x4 x0))))) (or (or (and (or (or x0 x7) (or x4 x4)) (or (or x5 x4) (and x0 x4))) (or (not (and x7 x3)) (or (and x8 x0) (or x7 x8)))) (not (not (and (not x9) (and x1 x9)))))))) (not (and (or (not (not (and (and (and x4 x1) (or x5 x1)) (and (or x5 x4) (not x5))))) (not (not (and (or (and x3 x7) (or x2 x7)) (or (or x5 x0) (or x7 x4)))))) (not (not (not (not (or (or x3 x0) (or x7 x7)))))))))) +(check-sat) +(pop 1) +(assert (or (not (or (and (or (not (and (or x8 x0) (and x5 x2))) (not (not (or x6 x0)))) (not (and (or (or x6 x9) (and x5 x7)) (and (or x1 x7) (and x0 x0))))) (or (and (and (not (not x1)) (not (and x8 x5))) (and (and (and x5 x2) (and x7 x1)) (not (and x0 x0)))) (or (not (and (and x3 x5) (not x3))) (not (or (and x1 x0) (and x2 x4))))))) (not (and (and (and (not (or (not x4) (or x3 x7))) (not (not (not x3)))) (or (not (not (and x2 x1))) (and (or (not x6) (and x0 x8)) (not (not x3))))) (or (or (not (and (or x2 x5) (and x9 x8))) (or (or (and x2 x6) (not x3)) (not (and x7 x3)))) (or (or (not (or x6 x4)) (not (not x0))) (or (or (not x3) (or x6 x7)) (not (and x6 x7))))))))) +(check-sat) +(push 1) +(assert (or (and (or (and (or (or (and (not x5) (not x9)) (or (and x3 x6) (and x3 x4))) (not (or (not x5) (or x6 x4)))) (and (and (and (not x4) (not x1)) (not (and x6 x2))) (and (or (not x4) (not x8)) (or (and x1 x3) (not x6))))) (not (not (and (or (not x8) (and x9 x1)) (and (not x3) (or x9 x4)))))) (not (and (or (not (or (or x1 x8) (or x9 x5))) (not (not (or x8 x8)))) (and (not (not (and x2 x5))) (or (or (not x6) (or x1 x2)) (or (not x0) (and x8 x4))))))) (and (or (or (and (and (not (and x7 x8)) (or (or x8 x3) (or x5 x2))) (not (or (and x3 x0) (and x8 x1)))) (or (and (and (not x2) (and x2 x2)) (or (not x1) (and x6 x6))) (or (and (not x2) (or x6 x9)) (not (and x8 x3))))) (not (and (or (or (or x7 x1) (not x6)) (and (and x6 x5) (not x8))) (not (not (not x4)))))) (and (not (not (or (or (or x6 x5) (not x6)) (or (or x7 x8) (or x2 x2))))) (not (or (and (or (and x1 x3) (not x7)) (and (and x4 x9) (or x2 x2))) (or (not (or x9 x7)) (not (and x5 x2))))))))) +(assert (and (not (and (and (or x2 x3) (or x1 x6)) (and (and x3 x6) (or x0 x7)))) (not (or (or (or x4 x0) (and x3 x4)) (and (not x6) (or x5 x8)))))) +(check-sat) +(push 1) +(assert (not (and (and (and x4 x6) (or x9 x4)) (or (and x1 x9) (not x1))))) +(check-sat) +(push 1) +(assert (or (not (and (or (and (not x2) (not x5)) (not (and x0 x5))) (not (and (and x2 x9) (and x2 x3))))) (not (not (and (not (or x7 x9)) (and (and x7 x4) (or x8 x3))))))) +(check-sat) +(pop 1) +(assert (not (or x0 x0))) +(assert (not (not (or (or (and (and (not (or (and (not x0) (not x1)) (and (and x4 x9) (and x3 x9)))) (not (or (not (or x9 x3)) (and (and x4 x2) (not x7))))) (and (not (and (or (not x1) (and x9 x5)) (not (or x9 x3)))) (and (or (and (or x6 x1) (or x6 x6)) (or (not x0) (not x0))) (or (and (not x3) (and x5 x7)) (not (and x9 x7)))))) (not (not (or (not (or (and x1 x0) (not x5))) (or (and (or x5 x5) (and x5 x7)) (and (and x1 x7) (and x4 x6))))))) (and (not (not (or (or (or (or x9 x0) (or x7 x3)) (or (not x0) (or x8 x0))) (and (or (and x3 x1) (or x4 x7)) (and (not x5) (and x0 x1)))))) (or (or (and (and (or (not x0) (not x2)) (not (and x3 x9))) (or (and (or x9 x6) (or x6 x0)) (or (not x6) (or x8 x0)))) (not (or (and (and x8 x6) (not x1)) (and (not x4) (or x5 x3))))) (or (or (or (or (and x2 x7) (and x5 x4)) (and (or x7 x5) (or x7 x8))) (and (not (and x7 x0)) (and (not x2) (not x0)))) (and (and (or (and x9 x6) (or x5 x9)) (not (or x8 x3))) (or (and (or x8 x4) (and x5 x2)) (or (or x5 x1) (and x5 x8))))))))))) +(assert (and (or (and (or (and (not (and x3 x6)) (or (and x1 x3) (not x2))) (and (not (not x7)) (and (not x1) (not x5)))) (not (not (not (or x6 x5))))) (or (and (or (not (and x2 x0)) (and (or x6 x8) (and x9 x2))) (or (not (and x7 x3)) (and (not x3) (or x7 x0)))) (not (or (not (not x2)) (or (or x3 x7) (not x9)))))) (and (not (or (and (not (or x9 x3)) (or (not x6) (and x1 x2))) (and (or (or x2 x3) (and x6 x7)) (and (and x2 x8) (and x5 x7))))) (not (or (not (and (not x0) (and x8 x1))) (not (not (or x7 x2)))))))) +(check-sat) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(assert (or (or (and (not (not (and (and x1 x3) (or x3 x1)))) (or (not (and (or x2 x0) (and x0 x1))) (or (not (or x2 x1)) (or (and x1 x3) (not x3))))) (not (not (or (or (and x3 x1) (not x0)) (and (and x1 x1) (or x0 x3)))))) (and (not (and (and (not (and x1 x3)) (or (or x0 x2) (not x2))) (or (or (or x0 x3) (and x3 x0)) (or (or x0 x3) (and x1 x0))))) (or (not (or (not (and x3 x1)) (and (and x0 x0) (and x1 x2)))) (not (or (or (not x0) (and x0 x2)) (and (or x0 x0) (and x3 x1)))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (and x2 x0)))) +(check-sat) +(pop 1) +(assert (not (not (not x1)))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(check-sat) +(push 1) +(assert (or (not (or (and x1 x0) (or x1 x0))) (not (not (not x0))))) +(check-sat) +(push 1) +(assert (or (not (or (and (or (or (and (or (not x0) (not x0)) (not (not x0))) (not (not (and x0 x0)))) (and (or (or (and x0 x0) (and x1 x0)) (not (or x1 x0))) (and (and (and x1 x0) (and x0 x0)) (and (not x0) (or x0 x1))))) (and (and (and (or (or x1 x0) (not x1)) (and (or x1 x0) (or x1 x1))) (and (and (not x1) (and x0 x0)) (and (or x0 x0) (not x1)))) (not (not (not (or x0 x1)))))) (and (not (and (and (or (and x0 x1) (not x0)) (or (and x1 x1) (or x0 x0))) (and (or (or x1 x1) (not x0)) (and (not x1) (or x1 x1))))) (or (and (or (or (or x0 x0) (not x0)) (or (and x0 x0) (or x1 x1))) (not (and (and x0 x0) (or x0 x1)))) (not (not (or (and x0 x1) (not x0)))))))) (or (or (and (and (or (or (and (not x1) (not x1)) (and (not x0) (not x1))) (and (and (or x1 x0) (and x0 x0)) (and (or x1 x0) (not x1)))) (and (not (or (or x1 x1) (and x0 x0))) (or (or (or x0 x0) (not x0)) (and (and x1 x0) (not x1))))) (and (and (or (or (not x0) (not x0)) (not (and x1 x0))) (not (and (not x1) (not x1)))) (and (or (and (and x1 x0) (and x0 x0)) (not (not x1))) (not (or (not x1) (or x0 x1)))))) (or (not (and (not (and (and x0 x0) (or x1 x0))) (or (or (or x1 x0) (not x1)) (or (not x1) (not x1))))) (and (not (or (and (not x0) (and x1 x0)) (or (and x1 x1) (or x0 x1)))) (not (or (and (or x0 x1) (not x1)) (not (or x1 x0))))))) (or (and (or (not (or (and (and x1 x0) (or x0 x1)) (and (and x0 x1) (and x0 x0)))) (and (not (or (and x0 x1) (not x1))) (or (not (not x0)) (not (or x1 x0))))) (or (or (or (and (or x1 x0) (not x0)) (and (and x1 x1) (not x0))) (not (not (or x0 x1)))) (and (not (and (and x1 x1) (not x1))) (and (and (and x0 x1) (or x1 x0)) (and (and x1 x1) (or x1 x1)))))) (and (not (not (or (and (or x1 x1) (and x0 x0)) (not (not x1))))) (not (not (or (and (not x1) (or x0 x0)) (or (and x0 x0) (and x1 x1)))))))))) +(check-sat) +(push 1) +(assert (and (not x0) (or x1 x0))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (not (and x1 x1))))) +(check-sat) +(pop 1) +(check-sat) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(check-sat) +(push 1) +(assert (or x1 x3)) +(assert (or (or x5 x0) (not x0))) +(check-sat) +(push 1) +(assert (and (not (or (or (not (or (or (or (and (not x2) (not x0)) (or (and x1 x0) (not x3))) (not (or (and x2 x8) (and x6 x6)))) (or (not (not (not x4))) (and (or (and x1 x1) (not x1)) (or (not x1) (not x6)))))) (not (or (and (or (and (not x4) (and x0 x6)) (and (not x1) (or x8 x1))) (not (not (not x0)))) (not (and (not (not x4)) (and (not x3) (and x2 x0))))))) (or (and (or (and (not (or (not x7) (and x1 x2))) (and (not (not x1)) (and (not x1) (or x3 x2)))) (or (or (and (and x2 x0) (or x3 x2)) (and (and x0 x1) (or x0 x5))) (not (and (and x3 x8) (not x4))))) (and (and (not (and (and x1 x5) (or x1 x6))) (and (or (or x4 x7) (and x4 x3)) (or (or x2 x0) (or x5 x1)))) (or (or (not (not x1)) (or (and x6 x1) (or x4 x2))) (not (and (and x0 x8) (and x7 x1)))))) (and (or (or (and (and (and x6 x8) (and x3 x7)) (and (and x7 x0) (or x5 x6))) (and (or (or x5 x6) (and x8 x7)) (and (and x0 x6) (and x1 x1)))) (and (not (or (not x1) (or x1 x2))) (and (and (or x2 x8) (not x5)) (not (or x0 x3))))) (or (and (and (not (not x3)) (not (or x1 x6))) (and (not (not x8)) (or (and x0 x6) (or x0 x8)))) (not (and (or (not x3) (or x4 x3)) (and (not x7) (not x7))))))))) (and (or (not (or (and (or (or (not (or x2 x2)) (not (and x0 x8))) (or (or (not x8) (not x8)) (and (not x0) (and x1 x4)))) (and (or (not (or x4 x0)) (not (or x1 x6))) (and (and (and x4 x7) (or x3 x5)) (and (or x6 x6) (and x0 x3))))) (or (or (or (and (not x6) (and x2 x6)) (and (not x6) (or x5 x5))) (and (or (or x2 x8) (not x1)) (or (or x8 x4) (or x3 x5)))) (and (or (or (and x7 x8) (not x2)) (or (and x8 x2) (and x3 x2))) (or (or (and x2 x5) (and x1 x8)) (or (not x8) (not x5))))))) (not (not (and (and (or (not (and x8 x0)) (or (not x0) (not x8))) (or (and (and x3 x7) (not x8)) (and (and x4 x7) (and x8 x0)))) (or (and (or (and x1 x5) (not x2)) (not (and x8 x5))) (and (and (and x1 x8) (not x2)) (and (not x7) (or x5 x6)))))))) (not (and (and (or (or (not (and (not x6) (not x7))) (or (or (and x3 x7) (and x7 x0)) (not (not x8)))) (not (and (not (or x4 x6)) (and (not x1) (and x4 x3))))) (not (not (and (or (not x8) (and x5 x8)) (and (or x0 x5) (and x7 x3)))))) (not (and (not (and (not (and x6 x8)) (or (not x7) (and x3 x0)))) (or (not (not (and x8 x0))) (or (or (not x0) (not x6)) (or (not x8) (or x0 x7))))))))))) +(check-sat) +(push 1) +(assert (or (or x5 x6) (not x3))) +(assert (or (and (not (and (not (or (not (or x1 x5)) (or (and x2 x4) (and x1 x1)))) (and (or (and (or x5 x1) (and x2 x6)) (not (or x7 x6))) (or (not (and x7 x3)) (or (and x3 x7) (or x8 x4)))))) (and (or (and (or (not (not x6)) (or (and x6 x0) (not x7))) (or (not (not x0)) (or (not x8) (or x5 x6)))) (and (or (not (or x5 x2)) (not (or x8 x6))) (and (not (or x5 x2)) (and (and x7 x1) (and x3 x1))))) (and (not (not (or (or x8 x4) (not x3)))) (not (not (or (or x8 x2) (and x0 x8))))))) (and (not (or (and (not (not (not x4))) (or (or (or x5 x3) (not x1)) (not (not x2)))) (not (or (and (not x7) (not x5)) (and (and x5 x5) (not x3)))))) (and (not (or (or (not (not x3)) (or (and x4 x7) (and x7 x1))) (not (and (and x2 x1) (not x1))))) (and (and (or (and (not x0) (and x6 x2)) (and (and x8 x2) (not x5))) (not (not (or x6 x2)))) (not (not (and (and x2 x7) (not x2))))))))) +(check-sat) +(push 1) +(assert (or (or (not x6) (or x4 x3)) (or (or x8 x6) (not x4)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (or (or (and (or (and (not (not (and (and x6 x0) (not x1)))) (not (or (and (and x4 x3) (and x1 x0)) (not (not x7))))) (and (not (not (and (and x3 x7) (or x5 x8)))) (and (not (and (or x4 x0) (or x1 x8))) (or (and (and x8 x6) (and x4 x7)) (not (or x1 x4)))))) (not (not (or (and (or (and x6 x0) (and x6 x3)) (or (not x3) (not x6))) (not (or (or x3 x5) (not x2))))))) (or (and (and (and (and (not (and x2 x4)) (or (not x3) (and x1 x8))) (or (or (not x6) (and x2 x7)) (and (and x0 x2) (not x1)))) (or (and (or (or x5 x6) (or x3 x3)) (not (or x7 x2))) (not (or (or x0 x8) (or x7 x2))))) (and (or (not (and (and x0 x8) (and x2 x1))) (not (and (not x7) (and x8 x1)))) (and (not (and (not x8) (or x2 x8))) (and (or (not x3) (not x7)) (not (not x7)))))) (or (and (not (or (or (not x7) (or x4 x7)) (and (not x7) (or x2 x7)))) (and (and (or (not x4) (or x6 x3)) (not (and x2 x4))) (and (not (or x1 x6)) (or (not x3) (or x1 x1))))) (not (or (not (not (not x5))) (not (or (or x4 x1) (not x0)))))))) (not (and (or (not (not (or (and (and x8 x7) (and x3 x5)) (or (and x1 x3) (or x0 x1))))) (not (not (or (or (not x0) (and x7 x8)) (not (not x2)))))) (or (or (not (or (or (or x8 x6) (or x4 x0)) (or (and x2 x7) (and x8 x8)))) (not (or (not (or x1 x2)) (not (not x7))))) (not (not (and (not (or x7 x4)) (and (not x0) (and x2 x1))))))))) (not (or (and (and (or (and (and (and (or x7 x1) (or x5 x2)) (or (not x8) (not x1))) (not (or (and x5 x4) (not x4)))) (and (or (or (and x7 x2) (not x4)) (not (or x8 x6))) (and (or (not x3) (and x7 x3)) (not (or x2 x4))))) (or (not (not (and (or x4 x7) (and x1 x5)))) (not (not (and (not x5) (not x2)))))) (not (not (not (and (not (not x7)) (not (and x1 x7))))))) (or (and (or (or (and (or (not x7) (not x6)) (or (or x2 x3) (or x2 x7))) (not (and (or x8 x8) (and x1 x8)))) (and (not (and (not x7) (not x6))) (or (and (and x5 x4) (or x1 x7)) (and (and x2 x1) (not x6))))) (or (or (or (or (and x3 x8) (not x4)) (and (or x2 x6) (and x0 x0))) (and (and (and x1 x3) (or x4 x2)) (not (or x4 x8)))) (or (and (not (or x8 x8)) (and (or x0 x3) (or x3 x0))) (and (not (and x5 x3)) (and (not x0) (and x3 x1)))))) (not (and (and (and (or (or x0 x3) (and x3 x7)) (and (or x3 x1) (and x4 x8))) (and (not (and x7 x6)) (or (not x0) (not x0)))) (and (or (and (or x0 x3) (not x0)) (or (or x1 x2) (or x8 x3))) (and (or (not x0) (or x2 x4)) (not (or x1 x1))))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 3) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (or x1 x1) (not x4))) +(assert (not (and (or (not (or (and (and x2 x0) (and x1 x4)) (and (or x4 x1) (and x2 x6)))) (and (or (not (and x4 x2)) (or (and x4 x3) (not x3))) (or (or (not x0) (or x2 x2)) (not (or x5 x6))))) (not (not (not (or (or x5 x6) (or x0 x3)))))))) +(check-sat) +(push 1) +(assert (not (not (or (not x4) (not x6))))) +(assert (not (and (not (or (and (and (or (not (or x3 x4)) (or (and x0 x3) (or x3 x3))) (and (or (and x2 x1) (or x2 x4)) (and (not x2) (or x6 x2)))) (not (not (and (or x0 x1) (and x6 x4))))) (and (or (and (and (not x3) (not x2)) (or (or x3 x0) (and x4 x0))) (and (and (and x5 x0) (not x6)) (not (not x0)))) (or (and (not (and x2 x4)) (not (or x0 x2))) (not (not (and x6 x3))))))) (and (or (or (or (or (not (or x4 x1)) (not (and x6 x4))) (and (and (or x3 x0) (and x3 x2)) (or (or x6 x6) (and x5 x5)))) (not (not (and (and x6 x3) (or x2 x2))))) (or (or (and (not (not x3)) (or (and x5 x4) (or x3 x1))) (and (or (not x6) (or x6 x2)) (or (not x4) (or x4 x6)))) (or (and (not (and x0 x2)) (not (not x0))) (not (or (or x5 x1) (and x0 x4)))))) (and (or (and (or (not (and x0 x6)) (not (and x1 x5))) (or (or (or x2 x4) (or x1 x6)) (or (not x4) (or x3 x4)))) (and (or (not (or x6 x0)) (and (and x2 x0) (or x0 x4))) (not (or (not x3) (or x4 x0))))) (or (not (not (or (and x6 x5) (and x6 x6)))) (and (not (or (or x4 x5) (or x3 x0))) (not (and (not x2) (not x5)))))))))) +(assert (or (not (not (and (not (and (and (not (or x1 x2)) (and (not x6) (or x3 x5))) (and (not (or x0 x2)) (not (or x4 x1))))) (or (or (not (not (and x4 x6))) (or (and (or x6 x4) (or x2 x3)) (or (and x6 x6) (not x3)))) (not (and (and (or x1 x3) (or x3 x0)) (or (not x2) (not x4)))))))) (not (or (not (and (not (or (or (not x6) (and x0 x1)) (and (or x5 x0) (and x0 x6)))) (not (not (and (and x5 x6) (and x4 x5)))))) (not (and (not (or (and (not x6) (or x1 x5)) (or (or x5 x6) (and x3 x6)))) (and (not (not (or x1 x4))) (and (or (or x4 x6) (or x2 x2)) (not (or x2 x6)))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (or (not (or (or (and (not (not (or x4 x6))) (not (not (or x6 x1)))) (or (not (or (and x6 x5) (or x4 x1))) (or (or (or x3 x4) (not x4)) (not (not x3))))) (or (or (and (or (and x3 x0) (and x2 x1)) (or (not x4) (or x4 x1))) (and (and (or x1 x2) (and x6 x6)) (not (or x3 x5)))) (or (and (and (and x5 x5) (not x3)) (not (or x0 x0))) (or (or (or x4 x2) (or x5 x1)) (and (or x1 x2) (not x0))))))) (or (and (not (not (and (or (and x6 x2) (and x2 x4)) (or (and x2 x1) (and x1 x1))))) (and (or (or (and (or x3 x0) (or x4 x2)) (or (or x0 x2) (and x0 x0))) (and (not (and x4 x6)) (not (and x5 x6)))) (and (and (and (not x1) (not x6)) (and (not x0) (and x1 x0))) (and (not (or x4 x6)) (or (or x0 x5) (not x0)))))) (or (and (not (or (not (and x1 x5)) (not (not x5)))) (or (or (and (and x6 x3) (and x0 x1)) (not (or x5 x1))) (and (and (or x6 x1) (not x4)) (and (or x1 x5) (or x4 x6))))) (and (not (or (and (not x4) (and x4 x3)) (or (not x1) (not x1)))) (or (or (and (and x3 x1) (and x4 x5)) (not (and x5 x0))) (and (not (not x3)) (or (and x5 x6) (and x3 x5)))))))) (or (and (not (or (and (not (not (and x5 x6))) (or (and (not x1) (not x4)) (or (and x0 x5) (not x1)))) (not (or (and (and x1 x3) (or x2 x1)) (and (or x6 x2) (not x5)))))) (not (and (and (or (and (not x3) (not x5)) (or (or x1 x3) (or x1 x2))) (and (or (and x4 x4) (not x1)) (and (or x6 x0) (not x1)))) (and (and (or (or x1 x2) (and x2 x3)) (and (not x6) (and x2 x2))) (or (not (or x4 x6)) (not (or x1 x3))))))) (and (or (not (or (not (not (not x3))) (or (not (not x0)) (not (and x2 x1))))) (or (not (or (not (not x3)) (not (not x6)))) (or (and (not (and x5 x3)) (not (or x3 x2))) (or (and (or x0 x2) (and x1 x2)) (or (not x2) (not x6)))))) (not (not (not (and (and (and x0 x0) (not x3)) (and (and x6 x4) (and x1 x5)))))))))) +(check-sat) +(push 1) +(assert (not (not (and x3 x3)))) +(check-sat) +(pop 1) +(assert (not (or x4 x2))) +(assert (and (not (and x3 x3)) (or (not x2) (or x4 x2)))) +(assert (and (or x0 x1) (or x2 x5))) +(check-sat) +(pop 5) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (and (and (and (and (not (or (or x2 x3) (and x5 x1))) (or (or (and x5 x2) (or x6 x0)) (not (and x3 x5)))) (and (and (and (and x2 x4) (and x4 x5)) (or (not x6) (and x6 x6))) (or (and (not x6) (and x0 x6)) (not (not x0))))) (or (or (and (and (not x3) (not x4)) (or (and x4 x6) (or x1 x5))) (and (or (not x2) (and x1 x3)) (or (and x2 x4) (or x6 x4)))) (and (or (not (not x0)) (or (and x1 x3) (or x3 x4))) (or (and (not x2) (not x3)) (or (and x6 x3) (or x0 x2)))))) (or (and (not (or (and (and x1 x5) (and x3 x3)) (not (and x4 x5)))) (or (and (or (or x3 x1) (or x2 x5)) (and (or x4 x6) (not x2))) (not (not (and x1 x1))))) (or (or (or (not (not x4)) (or (and x6 x5) (not x0))) (not (or (and x0 x0) (and x1 x3)))) (or (not (and (or x0 x0) (or x1 x1))) (or (not (and x5 x4)) (and (and x6 x6) (or x5 x5)))))))) (or (and (not (or (or (and (not (and x6 x2)) (or (not x1) (and x5 x6))) (and (or (and x5 x1) (and x2 x3)) (not (not x2)))) (not (or (or (and x1 x0) (and x6 x4)) (or (and x5 x5) (not x5)))))) (not (and (or (not (and (and x5 x3) (and x6 x3))) (or (not (not x2)) (and (and x6 x5) (and x0 x6)))) (not (and (not (or x3 x6)) (or (not x4) (or x0 x4))))))) (not (not (and (not (and (or (or x0 x1) (not x6)) (or (and x4 x0) (and x1 x6)))) (and (not (and (or x2 x0) (not x2))) (not (or (not x3) (or x0 x6)))))))))) +(assert (and (and (not (not x1)) (not (or x2 x0))) (and (and (not x4) (and x3 x3)) (or (not x4) (and x6 x4))))) +(assert (or (or (or (or (and x6 x0) (not x6)) (and (or x5 x0) (or x0 x6))) (not (not (or x0 x0)))) (or (or (or (not x3) (not x1)) (and (not x2) (and x5 x4))) (not (and (not x5) (not x6)))))) +(assert (and (or (and (not (and x0 x2)) (or (not x0) (or x6 x2))) (or (not (and x2 x0)) (and (not x5) (not x4)))) (not (and (or (or x2 x5) (not x2)) (not (and x0 x1)))))) +(assert (and (or (and x4 x5) (and x4 x4)) (or (not x4) (or x4 x0)))) +(assert (and x2 x6)) +(assert (or (or (and (or x5 x6) (or x6 x4)) (or (not x2) (and x3 x0))) (not (or (and x1 x6) (not x2))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (not (and (and (not (or (or x2 x3) (and x1 x6))) (and (and (and x2 x1) (and x2 x4)) (not (or x2 x1)))) (or (not (not (or x4 x6))) (or (or (or x1 x6) (or x4 x4)) (or (or x5 x4) (and x4 x5)))))) (or (and (not (not (or (and x0 x2) (and x6 x6)))) (and (and (or (or x3 x2) (and x4 x2)) (or (not x6) (not x2))) (not (not (not x4))))) (and (or (and (not (or x1 x6)) (or (and x6 x0) (or x6 x1))) (and (and (and x0 x0) (not x3)) (or (not x2) (not x5)))) (or (not (not (or x6 x2))) (or (or (and x5 x6) (or x1 x3)) (or (and x4 x2) (and x1 x0))))))) (not (or (or (not (and (and (and x0 x6) (and x0 x1)) (and (or x0 x3) (or x3 x5)))) (not (or (not (not x3)) (not (or x0 x3))))) (and (and (and (and (and x0 x0) (not x0)) (not (and x4 x6))) (or (or (not x2) (not x2)) (or (not x5) (not x0)))) (or (or (or (and x5 x2) (or x5 x0)) (and (and x2 x0) (not x0))) (not (not (or x2 x4))))))))) +(check-sat) +(push 1) +(assert (and (and (or (and (or (or (not x2) (or x6 x4)) (not (not x4))) (or (not (or x3 x0)) (or (and x5 x6) (or x3 x2)))) (and (not (and (or x1 x5) (and x5 x6))) (or (and (or x2 x4) (or x4 x2)) (or (or x6 x6) (and x2 x6))))) (not (not (or (or (not x4) (and x5 x3)) (and (not x2) (and x4 x0)))))) (not (and (not (and (and (not x6) (not x2)) (not (or x6 x5)))) (not (or (not (and x2 x5)) (not (not x0)))))))) +(assert (not x2)) +(assert (and (not (and (and (and (or (not (or (not x3) (not x0))) (and (or (and x4 x0) (not x0)) (not (not x3)))) (not (not (or (and x2 x4) (and x0 x0))))) (not (or (and (or (not x4) (and x5 x1)) (or (or x1 x2) (and x4 x0))) (and (not (and x1 x5)) (and (and x5 x4) (or x1 x6)))))) (and (or (or (or (and (not x3) (and x0 x3)) (and (not x4) (not x1))) (not (or (or x0 x0) (or x0 x1)))) (or (and (and (and x3 x0) (or x2 x6)) (and (or x4 x5) (not x0))) (not (or (or x6 x3) (not x0))))) (not (and (and (and (or x6 x5) (not x0)) (and (and x1 x6) (not x1))) (and (or (or x2 x5) (or x5 x6)) (not (not x0)))))))) (or (or (and (not (and (or (not (or x4 x2)) (and (and x5 x2) (or x6 x1))) (or (not (and x2 x5)) (not (not x2))))) (and (and (or (or (and x6 x0) (not x5)) (or (and x3 x3) (not x1))) (and (and (not x2) (not x2)) (and (or x0 x3) (not x0)))) (and (not (and (or x6 x2) (and x5 x1))) (not (not (and x1 x4)))))) (or (or (and (or (and (not x3) (or x4 x1)) (and (or x2 x6) (and x2 x6))) (or (and (or x0 x1) (not x6)) (or (and x2 x3) (or x3 x0)))) (or (and (or (and x2 x3) (not x6)) (not (and x3 x2))) (and (or (not x3) (and x1 x3)) (and (not x2) (and x1 x6))))) (or (and (not (and (and x2 x4) (not x1))) (or (or (and x2 x2) (and x1 x5)) (not (not x5)))) (and (or (and (not x5) (or x2 x0)) (and (and x0 x6) (or x2 x3))) (and (and (and x0 x4) (and x3 x1)) (not (and x3 x2))))))) (or (or (not (not (not (or (or x6 x2) (or x1 x0))))) (not (and (not (not (not x1))) (not (and (or x1 x6) (and x3 x2)))))) (and (or (and (not (or (and x6 x0) (and x4 x3))) (and (not (not x2)) (or (not x1) (not x2)))) (or (not (or (not x2) (and x3 x6))) (or (or (not x3) (and x4 x1)) (not (and x5 x3))))) (not (or (and (and (or x6 x6) (and x1 x0)) (and (and x0 x6) (not x0))) (not (and (and x5 x1) (not x4)))))))))) +(assert (and (and (and (or (and (and (or (not x6) (and x5 x4)) (or (and x5 x4) (or x0 x2))) (and (and (and x6 x3) (not x4)) (and (not x2) (or x3 x1)))) (and (not (or (or x4 x4) (or x2 x4))) (or (or (and x2 x2) (or x2 x1)) (or (not x1) (and x5 x4))))) (or (and (not (or (not x5) (not x2))) (not (and (not x2) (and x4 x6)))) (or (not (and (and x2 x1) (or x3 x1))) (and (not (not x2)) (and (and x4 x5) (not x3)))))) (or (not (not (not (not (not x5))))) (and (not (or (or (or x4 x3) (and x0 x6)) (and (or x2 x2) (and x6 x1)))) (or (not (not (not x3))) (not (or (or x0 x1) (not x3))))))) (or (or (or (not (and (not (or x4 x6)) (not (not x3)))) (or (not (and (not x3) (or x2 x2))) (or (not (and x4 x0)) (or (or x5 x6) (not x1))))) (and (or (or (and (not x2) (and x0 x2)) (or (not x5) (not x5))) (and (and (and x4 x5) (and x5 x3)) (or (not x3) (or x5 x1)))) (not (not (not (or x1 x6)))))) (and (or (or (or (or (and x2 x4) (or x4 x2)) (and (not x1) (or x5 x3))) (or (and (or x5 x2) (and x1 x1)) (and (not x1) (and x5 x6)))) (and (not (or (and x1 x3) (or x5 x3))) (and (and (not x2) (not x2)) (and (and x5 x5) (and x1 x6))))) (or (or (and (and (not x0) (or x3 x6)) (not (and x5 x4))) (and (or (not x3) (or x3 x6)) (not (and x4 x6)))) (not (and (not (or x5 x3)) (and (not x3) (or x2 x1))))))))) +(check-sat) +(pop 1) +(assert (or (not (or (not (and (or (or (and x3 x5) (not x5)) (and (and x5 x2) (not x0))) (not (not (or x6 x5))))) (or (or (not (not (and x0 x6))) (and (not (not x6)) (or (and x6 x5) (or x0 x3)))) (or (and (not (not x4)) (and (and x2 x3) (and x4 x2))) (and (or (or x3 x5) (not x1)) (and (or x5 x2) (or x6 x4))))))) (and (not (and (or (or (and (and x6 x0) (and x1 x2)) (and (and x0 x3) (or x6 x4))) (and (not (or x4 x1)) (and (and x0 x4) (not x4)))) (or (or (and (not x0) (and x4 x1)) (not (or x0 x0))) (and (and (not x5) (and x1 x3)) (not (and x3 x2)))))) (not (not (not (and (not (and x0 x0)) (not (not x0))))))))) +(assert (and (or (or (and x3 x2) (and x1 x6)) (or (or x6 x3) (not x0))) (or (not (and x5 x5)) (or (not x1) (or x3 x6))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (or (not (not (and (and (not (and x2 x5)) (and (or x1 x2) (not x1))) (not (or (or x0 x2) (not x6)))))) (not (or (or (and (or (not x1) (not x6)) (and (not x3) (or x6 x0))) (and (not (or x4 x1)) (or (or x1 x6) (or x1 x2)))) (and (not (not (not x0))) (or (not (and x2 x6)) (not (and x5 x3))))))) (not (and (and (or (not (and (or x5 x4) (and x1 x1))) (and (or (or x1 x1) (not x3)) (and (and x3 x6) (and x6 x1)))) (and (or (or (or x5 x4) (not x2)) (or (not x2) (or x2 x4))) (not (and (not x6) (not x5))))) (and (and (not (or (and x0 x3) (and x3 x2))) (or (not (not x6)) (not (not x4)))) (or (and (and (not x3) (not x1)) (and (and x2 x4) (not x3))) (not (and (and x1 x1) (or x0 x4))))))))) +(assert (not (not (not (or (or (or (not x4) (or x1 x4)) (or (and x2 x3) (or x4 x5))) (and (not (not x5)) (and (and x0 x6) (and x5 x1)))))))) +(check-sat) +(pop 1) +(assert (and (and x2 x0) (not x4))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (or (or (or (not (or (and (and x5 x5) (not x5)) (or (or x1 x2) (not x1)))) (not (and (and (and x6 x5) (or x6 x5)) (and (or x6 x0) (and x6 x4))))) (and (or (or (or (not x3) (or x0 x1)) (or (or x0 x4) (or x6 x4))) (and (and (and x3 x4) (and x0 x0)) (or (and x6 x3) (or x3 x0)))) (not (or (and (or x1 x1) (or x1 x0)) (and (or x0 x3) (and x0 x5)))))) (or (or (and (and (not (not x5)) (and (or x4 x0) (or x3 x2))) (and (and (or x1 x2) (and x0 x2)) (and (and x4 x6) (and x0 x4)))) (or (not (and (and x5 x2) (or x1 x5))) (not (not (not x2))))) (or (not (or (not (and x3 x5)) (and (not x3) (and x2 x3)))) (and (or (and (and x2 x0) (or x6 x4)) (or (or x0 x2) (or x3 x3))) (or (or (not x1) (and x2 x4)) (not (and x2 x6))))))) (and (not (or (or (and (and (and x4 x4) (not x2)) (or (or x3 x2) (not x5))) (and (not (or x5 x2)) (not (or x2 x5)))) (or (not (not (or x3 x0))) (and (not (not x5)) (and (or x0 x1) (or x2 x5)))))) (and (not (and (or (and (and x5 x6) (not x0)) (and (or x0 x1) (and x4 x5))) (not (and (and x4 x0) (or x0 x4))))) (or (not (and (not (or x2 x5)) (or (not x0) (not x0)))) (or (and (or (or x3 x6) (not x2)) (and (not x5) (and x0 x2))) (not (or (or x6 x3) (not x6))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (or (or x4 x3) (and x5 x3)) (and (and x3 x2) (not x1)))) +(check-sat) +(push 1) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or x4 x2) (or x4 x2))) +(assert (not (not (or (not (or (and x3 x5) (not x6))) (or (or (or x1 x5) (or x0 x3)) (not (or x3 x6))))))) +(assert (or (and (and (or (and x1 x6) (or x2 x4)) (and (and x1 x0) (or x1 x4))) (and (not (and x3 x6)) (not (not x0)))) (and (not (not (and x4 x0))) (not (or (not x6) (and x6 x5)))))) +(assert (or (and (and (and (or (not (and (or (or (not x4) (not x3)) (not (and x3 x3))) (and (not (not x3)) (not (and x0 x2))))) (and (and (not (and (and x1 x0) (or x2 x2))) (or (or (or x3 x4) (not x0)) (not (not x5)))) (or (not (and (not x3) (or x4 x4))) (or (not (and x0 x2)) (not (or x3 x0)))))) (or (or (or (not (and (and x0 x6) (not x3))) (or (not (not x3)) (and (not x3) (or x5 x0)))) (or (and (or (or x0 x5) (and x6 x3)) (and (and x3 x6) (not x3))) (and (or (not x1) (or x4 x5)) (and (or x1 x6) (not x4))))) (and (not (and (and (or x0 x4) (or x3 x6)) (or (and x2 x3) (not x6)))) (and (not (or (not x5) (not x2))) (not (not (not x2))))))) (not (or (or (or (and (or (and x3 x5) (or x0 x0)) (not (and x5 x5))) (and (and (and x0 x1) (or x6 x4)) (or (not x4) (and x6 x5)))) (and (and (not (not x0)) (or (not x4) (and x4 x2))) (or (or (and x6 x1) (not x6)) (not (or x4 x2))))) (and (or (or (not (not x1)) (or (and x4 x4) (not x5))) (and (not (not x5)) (not (and x0 x6)))) (and (or (not (or x3 x0)) (not (or x3 x5))) (or (not (and x2 x2)) (and (and x2 x4) (or x4 x1)))))))) (and (not (or (or (and (or (not (not x5)) (or (or x3 x1) (not x1))) (and (not (or x5 x3)) (not (or x3 x0)))) (not (and (not (or x2 x5)) (and (or x1 x0) (and x0 x5))))) (and (or (and (not (and x3 x1)) (or (and x1 x4) (not x5))) (or (or (not x2) (not x4)) (not (not x4)))) (and (not (or (and x5 x1) (or x4 x5))) (not (and (or x2 x1) (not x1))))))) (or (not (not (and (and (not (not x0)) (and (or x0 x3) (not x0))) (or (and (and x0 x6) (and x0 x4)) (not (and x6 x5)))))) (and (and (or (not (not (and x4 x3))) (or (or (and x1 x4) (or x3 x4)) (not (or x2 x2)))) (or (not (or (and x6 x0) (or x2 x3))) (not (or (and x3 x2) (and x6 x5))))) (or (and (not (and (and x6 x0) (not x0))) (or (and (not x5) (and x3 x3)) (not (or x0 x2)))) (and (not (or (and x5 x3) (not x0))) (or (and (and x6 x4) (or x2 x5)) (or (or x5 x1) (or x0 x2))))))))) (or (not (or (or (not (and (or (or (not x2) (or x3 x0)) (not (and x0 x2))) (or (not (and x3 x4)) (or (and x3 x4) (or x2 x6))))) (not (not (not (not (not x1)))))) (not (or (and (or (not (or x2 x3)) (or (or x4 x3) (or x3 x4))) (and (or (not x0) (and x3 x3)) (and (not x2) (and x0 x0)))) (and (or (and (and x1 x3) (and x0 x0)) (and (and x2 x2) (not x3))) (and (or (and x4 x0) (or x4 x4)) (not (or x5 x0)))))))) (and (or (not (not (and (or (and (not x2) (not x6)) (and (and x3 x4) (not x5))) (or (not (not x2)) (and (not x0) (not x3)))))) (and (and (or (or (or (not x0) (not x3)) (or (or x3 x1) (not x0))) (and (not (not x2)) (or (and x6 x2) (not x2)))) (and (and (not (or x4 x4)) (not (or x0 x0))) (and (not (and x5 x5)) (and (not x2) (and x0 x0))))) (not (or (or (or (and x4 x5) (and x2 x5)) (not (and x6 x3))) (not (not (or x5 x4))))))) (or (not (not (and (or (not (or x6 x3)) (not (not x1))) (not (or (or x6 x0) (or x4 x6)))))) (or (not (and (not (not (and x3 x4))) (not (not (not x5))))) (and (and (not (or (or x5 x4) (not x4))) (not (not (or x6 x1)))) (and (not (and (and x1 x0) (or x0 x1))) (and (and (and x5 x2) (and x2 x5)) (or (not x1) (or x6 x4))))))))))) +(check-sat) +(push 1) +(assert (and (and (or (not (or (not x5) (and x3 x3))) (or (or (not x4) (or x5 x2)) (not (or x2 x0)))) (and (not (not (not x4))) (and (and (not x3) (or x5 x0)) (not (or x3 x5))))) (and (or (or (not (and x6 x4)) (or (and x2 x6) (and x2 x1))) (or (not (not x4)) (not (and x6 x3)))) (or (and (not (and x3 x3)) (not (or x0 x2))) (or (not (or x5 x4)) (or (and x2 x2) (and x1 x5))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (not (or (or (or (and (or (not (or x1 x0)) (not (or x2 x0))) (not (and (and x4 x3) (or x0 x6)))) (and (and (and (or x4 x1) (or x1 x2)) (or (not x1) (not x6))) (not (and (not x4) (and x6 x1))))) (or (and (and (not (not x6)) (or (and x6 x3) (not x1))) (or (or (and x5 x6) (or x5 x5)) (or (or x4 x6) (or x5 x6)))) (and (not (or (or x5 x2) (not x3))) (or (or (and x6 x6) (or x0 x5)) (or (and x1 x2) (and x6 x5)))))) (and (and (and (or (or (and x6 x2) (or x3 x5)) (and (or x6 x1) (and x1 x1))) (not (not (not x5)))) (or (or (not (or x3 x1)) (not (not x0))) (or (or (and x0 x4) (or x6 x6)) (and (not x2) (or x6 x1))))) (and (and (not (not (or x0 x1))) (not (or (or x2 x1) (not x1)))) (or (and (not (or x5 x2)) (or (not x0) (not x6))) (and (and (or x2 x4) (not x5)) (or (and x6 x5) (and x0 x6)))))))))) +(assert (or (or (or (and x2 x5) (and x5 x3)) (not (not x5))) (not (not (or x6 x2))))) +(assert (not x3)) +(check-sat) +(pop 1) +(check-sat) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(assert (not (and (or (and (and (and (or (not (and (not x4) (and x2 x4))) (not (or (or x2 x2) (or x0 x2)))) (not (and (or (or x2 x3) (or x0 x2)) (and (not x1) (not x1))))) (not (or (and (and (or x0 x4) (or x1 x1)) (and (and x3 x0) (not x1))) (or (not (and x3 x3)) (not (and x3 x1)))))) (or (not (not (not (not (and x3 x2))))) (not (or (or (not (or x0 x3)) (and (or x2 x2) (and x1 x0))) (not (and (and x2 x2) (or x0 x0))))))) (and (not (or (not (not (or (or x2 x3) (or x0 x4)))) (or (or (not (not x4)) (not (and x3 x3))) (and (not (not x0)) (and (not x2) (not x3)))))) (and (and (not (not (or (and x0 x1) (or x3 x4)))) (or (and (or (and x1 x2) (or x4 x1)) (or (or x4 x3) (not x4))) (not (and (not x1) (and x2 x1))))) (not (or (not (and (or x4 x0) (and x3 x2))) (not (and (and x0 x4) (not x0)))))))) (or (not (or (or (and (or (or (and x1 x1) (or x2 x1)) (and (not x3) (or x3 x1))) (and (and (and x3 x2) (and x0 x4)) (or (or x0 x4) (or x2 x4)))) (and (not (and (and x1 x2) (not x3))) (or (and (not x2) (or x3 x0)) (or (not x0) (not x2))))) (and (and (and (not (and x3 x3)) (not (not x0))) (or (or (and x0 x1) (not x2)) (not (or x3 x0)))) (or (and (or (and x0 x2) (and x0 x3)) (and (not x3) (or x0 x4))) (and (not (and x2 x1)) (not (not x1))))))) (and (not (not (and (not (or (not x4) (and x0 x0))) (or (not (not x0)) (or (and x1 x3) (and x2 x0)))))) (or (and (and (not (or (and x2 x1) (and x4 x1))) (and (not (and x0 x3)) (and (or x3 x2) (and x1 x4)))) (and (and (or (or x0 x1) (not x0)) (and (and x2 x3) (not x2))) (not (not (or x2 x3))))) (and (and (and (and (or x2 x1) (or x1 x4)) (and (and x2 x4) (or x1 x4))) (or (and (and x2 x0) (not x0)) (and (and x3 x1) (not x0)))) (or (not (or (not x4) (or x1 x2))) (and (or (not x2) (not x3)) (and (or x1 x2) (and x1 x1))))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (and (not (or (and (or x1 x0) (not x1)) (not (and x1 x3)))) (or (or (not (not x2)) (and (and x3 x3) (not x1))) (or (or (or x4 x3) (not x3)) (not (not x4)))))) (or (and (not (not (or (and x3 x3) (or x3 x0)))) (not (or (or (or x2 x4) (and x2 x1)) (or (not x2) (not x0))))) (and (not (or (and (not x1) (not x1)) (not (and x3 x0)))) (or (and (not (not x4)) (not (not x2))) (or (not (not x0)) (and (not x4) (or x2 x0)))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (and x4 x0)) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not x3)) +(assert (not (or x0 x2))) +(check-sat) +(pop 1) +(assert (and (and (not x4) (not x2)) (not (or x1 x2)))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (not (and (or (and (or (or (not (not (or (not x3) (or x9 x2)))) (and (not (or (and x8 x5) (and x0 x4))) (not (and (not x6) (not x1))))) (or (not (or (and (or x2 x9) (and x1 x9)) (not (not x2)))) (not (not (and (or x8 x0) (not x8)))))) (or (and (and (and (or (not x2) (not x5)) (not (or x1 x6))) (not (not (or x2 x4)))) (or (not (and (not x7) (or x1 x6))) (and (or (or x6 x7) (or x8 x7)) (not (and x0 x8))))) (and (not (and (and (and x2 x1) (and x0 x5)) (not (or x8 x8)))) (not (and (and (not x2) (or x5 x8)) (not (not x1))))))) (and (and (not (or (and (or (and x3 x3) (or x2 x5)) (and (or x8 x9) (not x2))) (and (or (not x5) (not x1)) (and (or x6 x7) (not x1))))) (not (and (and (and (or x1 x5) (and x4 x8)) (not (and x6 x4))) (and (or (or x0 x8) (and x3 x5)) (not (and x6 x1)))))) (not (and (and (not (or (or x0 x4) (or x9 x7))) (or (and (and x8 x4) (not x4)) (or (and x0 x5) (or x1 x9)))) (not (and (and (and x3 x5) (and x8 x6)) (and (or x9 x8) (or x2 x7)))))))) (or (or (or (or (or (not (or (or x8 x3) (or x3 x7))) (not (and (not x7) (or x1 x0)))) (and (or (and (or x5 x7) (or x3 x0)) (and (and x0 x6) (not x2))) (not (not (or x4 x3))))) (or (and (not (or (and x2 x4) (or x0 x6))) (not (and (and x6 x7) (not x3)))) (not (and (and (and x7 x5) (and x3 x0)) (and (not x8) (and x6 x1)))))) (and (not (not (not (or (not x2) (not x3))))) (or (or (not (and (not x8) (not x5))) (and (or (or x0 x1) (and x6 x1)) (not (not x1)))) (not (not (or (or x1 x5) (not x0))))))) (and (or (not (and (or (or (not x6) (not x7)) (and (not x3) (and x7 x3))) (and (not (not x0)) (and (not x1) (or x4 x6))))) (or (and (not (and (and x8 x7) (and x9 x7))) (not (or (not x2) (and x0 x6)))) (or (not (not (or x3 x3))) (not (not (or x9 x7)))))) (and (not (not (not (or (and x2 x2) (or x9 x7))))) (or (and (and (or (or x5 x7) (and x2 x0)) (and (or x8 x4) (not x7))) (not (not (and x6 x9)))) (and (not (not (not x0))) (or (and (not x9) (or x1 x7)) (not (or x9 x7))))))))))) +(assert (not (and (not (not (or x9 x8))) (or (not (not x9)) (or (and x4 x6) (or x3 x8)))))) +(assert (or (or (not (or (and (and (and x9 x5) (or x3 x6)) (not (not x9))) (and (and (and x7 x6) (and x8 x3)) (or (and x1 x8) (and x0 x9))))) (not (not (or (and (and x8 x7) (or x9 x2)) (and (not x1) (not x1)))))) (and (or (and (and (not (or x7 x2)) (not (or x6 x5))) (and (or (and x8 x6) (and x8 x7)) (or (not x6) (not x7)))) (or (or (not (not x3)) (and (and x0 x5) (not x4))) (and (not (or x7 x2)) (not (and x1 x9))))) (or (not (and (or (and x5 x4) (or x1 x0)) (or (and x6 x2) (not x1)))) (and (or (not (not x1)) (and (or x2 x7) (or x6 x1))) (not (or (and x2 x0) (not x4)))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (or (not (not (not (or (and (or (not x2) (and x1 x3)) (not (not x3))) (or (not (not x8)) (or (or x9 x7) (and x3 x3))))))) (not (or (and (not (or (or (and x6 x6) (not x6)) (and (not x1) (not x4)))) (and (not (not (and x9 x7))) (and (and (and x6 x9) (and x1 x2)) (not (or x3 x1))))) (or (or (or (not (not x9)) (not (and x4 x4))) (or (not (and x4 x0)) (or (not x0) (or x2 x0)))) (and (and (and (or x1 x1) (not x9)) (or (or x7 x7) (not x2))) (and (or (and x1 x7) (or x2 x9)) (and (not x2) (not x2)))))))) (and (or (not (and (not (and (not (or x5 x6)) (not (or x3 x8)))) (or (not (not (or x6 x3))) (and (or (or x6 x1) (not x9)) (not (or x8 x2)))))) (not (and (not (or (or (or x7 x1) (not x3)) (or (or x6 x9) (and x8 x1)))) (not (not (not (and x6 x7))))))) (or (not (not (and (and (or (not x3) (not x0)) (or (or x3 x3) (or x4 x3))) (or (and (and x8 x6) (or x7 x7)) (not (or x4 x4)))))) (and (and (and (not (or (or x2 x7) (not x6))) (and (or (not x2) (or x3 x6)) (and (not x8) (not x9)))) (and (not (and (or x1 x5) (and x6 x1))) (or (not (or x6 x1)) (or (or x0 x8) (not x5))))) (and (or (not (not (and x5 x3))) (or (not (or x8 x1)) (not (or x7 x4)))) (and (and (and (or x3 x0) (or x1 x4)) (and (or x6 x7) (not x1))) (or (or (not x0) (and x6 x5)) (not (not x4))))))))) (and (or (and (and (and (not (not (not (and x3 x6)))) (and (or (not (not x6)) (not (not x3))) (or (not (not x6)) (and (or x4 x9) (not x0))))) (and (or (not (not (or x5 x6))) (or (and (and x8 x2) (and x5 x2)) (or (or x0 x4) (or x4 x6)))) (or (and (or (not x0) (or x6 x4)) (not (and x5 x6))) (and (or (and x8 x7) (not x7)) (or (and x2 x5) (and x7 x5)))))) (or (and (not (not (or (not x7) (or x7 x8)))) (not (not (or (and x0 x9) (or x4 x6))))) (and (and (or (not (and x1 x4)) (not (and x5 x4))) (or (or (or x9 x0) (and x9 x9)) (not (or x7 x7)))) (or (not (or (not x3) (or x8 x0))) (or (not (or x3 x4)) (not (not x1))))))) (or (not (and (not (or (not (or x0 x6)) (or (not x9) (not x9)))) (or (not (not (and x6 x9))) (not (and (not x9) (and x8 x2)))))) (not (or (or (and (and (not x6) (or x7 x2)) (and (and x8 x5) (and x0 x8))) (and (not (not x7)) (or (not x6) (or x8 x9)))) (or (and (and (and x5 x6) (and x4 x2)) (and (or x1 x2) (not x4))) (not (and (and x4 x8) (and x7 x7)))))))) (or (and (and (or (or (or (and (and x5 x5) (or x8 x2)) (not (not x8))) (and (not (not x3)) (or (or x9 x8) (not x2)))) (and (or (and (and x4 x8) (and x7 x7)) (and (not x3) (and x8 x0))) (and (not (and x2 x5)) (and (and x9 x4) (and x5 x3))))) (not (and (or (not (not x7)) (and (not x1) (or x5 x1))) (not (not (and x6 x5)))))) (or (not (not (or (and (not x1) (or x1 x0)) (and (and x6 x8) (and x1 x0))))) (or (or (and (not (or x9 x2)) (or (and x5 x6) (and x1 x2))) (not (not (and x7 x2)))) (or (not (not (and x0 x3))) (or (not (and x8 x0)) (and (not x5) (not x7))))))) (or (or (or (and (and (or (and x9 x0) (or x1 x9)) (not (and x4 x4))) (and (and (not x8) (not x1)) (and (or x0 x9) (not x2)))) (not (not (not (not x2))))) (not (and (not (not (or x5 x1))) (and (or (not x9) (not x6)) (not (or x1 x6)))))) (not (or (or (and (and (or x5 x1) (not x1)) (and (not x4) (not x2))) (or (and (and x6 x2) (or x4 x3)) (and (and x1 x7) (and x8 x0)))) (or (or (not (or x9 x4)) (or (and x7 x8) (or x1 x6))) (or (or (or x0 x7) (and x6 x2)) (or (not x5) (not x0))))))))))) +(assert (not (and (and (and (and (or (and (or x7 x6) (and x4 x6)) (not (or x4 x2))) (and (and (or x7 x6) (or x9 x1)) (or (not x1) (and x1 x8)))) (not (not (and (or x7 x1) (not x7))))) (not (or (not (and (or x7 x2) (and x2 x2))) (or (and (or x5 x1) (and x8 x1)) (or (and x2 x8) (not x6)))))) (or (or (not (not (or (not x2) (or x2 x8)))) (not (and (not (not x9)) (not (and x9 x6))))) (and (or (or (not (and x1 x3)) (not (not x3))) (and (and (and x1 x4) (and x1 x9)) (not (or x1 x7)))) (not (not (or (not x2) (not x0))))))))) +(check-sat) +(push 1) +(assert (and (not (and (and (or (and (and (or (not (or x0 x2)) (not (and x3 x8))) (or (and (not x3) (or x1 x7)) (and (or x0 x3) (or x0 x0)))) (and (not (and (not x6) (not x9))) (or (not (and x9 x4)) (and (or x1 x3) (not x7))))) (or (not (and (and (not x9) (not x4)) (not (not x1)))) (not (or (or (or x7 x9) (and x0 x1)) (not (and x6 x3)))))) (or (not (not (or (and (not x5) (not x0)) (and (and x1 x9) (and x7 x1))))) (or (and (or (and (not x3) (or x9 x8)) (not (and x0 x6))) (not (not (not x5)))) (and (and (and (and x7 x6) (and x7 x2)) (and (not x9) (and x8 x1))) (and (not (not x4)) (not (or x5 x7))))))) (not (not (or (and (and (or (and x5 x6) (not x1)) (or (not x7) (not x6))) (and (or (and x3 x6) (or x4 x3)) (or (and x7 x3) (not x5)))) (or (not (not (or x7 x4))) (and (or (not x6) (or x4 x6)) (or (or x1 x3) (not x2))))))))) (or (and (not (and (or (and (not (not (and x3 x8))) (and (not (and x4 x9)) (not (not x0)))) (or (and (or (or x7 x5) (not x1)) (or (and x8 x0) (not x1))) (and (and (and x8 x9) (or x3 x2)) (not (not x9))))) (or (or (or (and (or x2 x6) (not x1)) (or (not x6) (not x4))) (or (or (not x4) (or x6 x7)) (and (and x8 x0) (and x3 x5)))) (or (and (not (or x1 x6)) (not (not x0))) (not (not (not x0))))))) (or (not (not (and (or (or (and x6 x5) (and x5 x6)) (not (or x9 x2))) (not (not (and x8 x0)))))) (or (not (and (not (not (and x1 x4))) (and (and (not x9) (and x4 x1)) (or (not x9) (not x7))))) (and (or (and (not (or x4 x1)) (not (and x9 x1))) (and (not (and x0 x4)) (and (or x8 x0) (not x5)))) (or (not (and (or x7 x1) (not x9))) (not (not (not x0)))))))) (not (or (or (not (or (and (not (not x3)) (and (or x5 x0) (not x1))) (not (not (not x8))))) (and (and (or (and (and x3 x3) (or x2 x3)) (not (or x5 x3))) (and (and (and x3 x2) (or x6 x8)) (and (or x8 x1) (not x9)))) (or (and (and (and x7 x0) (and x7 x4)) (and (and x8 x3) (not x4))) (not (not (not x8)))))) (and (not (and (not (and (or x6 x4) (or x9 x9))) (or (and (or x8 x3) (or x0 x0)) (not (or x0 x7))))) (or (and (or (and (and x5 x9) (or x7 x2)) (and (not x2) (not x4))) (and (or (not x8) (or x4 x4)) (not (or x9 x4)))) (or (not (not (and x0 x5))) (or (and (not x9) (not x5)) (not (or x7 x7))))))))))) +(assert (and (not (or x6 x8)) (or (or x4 x6) (or x4 x6)))) +(assert (or (or (not (not (and (or x3 x4) (or x4 x9)))) (or (not (and (not x2) (and x9 x7))) (and (and (and x4 x9) (not x2)) (not (and x8 x5))))) (or (or (and (not (not x3)) (or (and x9 x9) (and x1 x8))) (or (and (and x7 x3) (and x4 x8)) (not (not x4)))) (and (not (not (or x4 x5))) (and (or (or x7 x0) (and x2 x6)) (not (or x7 x7))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (and (or (not (and (or (or (or (not (not x9)) (not (and x2 x7))) (not (or (or x3 x5) (not x6)))) (not (and (and (and x9 x5) (and x2 x4)) (and (or x0 x9) (not x7))))) (and (or (not (and (not x8) (or x6 x7))) (not (and (or x7 x6) (or x3 x5)))) (and (and (and (and x4 x9) (or x0 x8)) (not (not x9))) (not (not (and x6 x1))))))) (or (not (and (and (and (not (or x0 x7)) (not (or x1 x7))) (and (or (or x4 x1) (or x3 x3)) (or (not x7) (or x3 x0)))) (or (and (and (not x6) (and x5 x0)) (not (or x8 x2))) (and (and (or x7 x0) (and x9 x8)) (and (and x0 x2) (not x2)))))) (and (not (not (not (and (not x2) (or x6 x1))))) (and (and (and (and (and x9 x7) (or x2 x0)) (and (or x5 x5) (and x6 x8))) (or (and (and x6 x9) (or x4 x1)) (not (and x5 x5)))) (and (not (and (not x0) (or x9 x1))) (not (not (or x0 x3)))))))) (or (not (and (not (and (or (not (or x2 x6)) (and (or x2 x6) (not x8))) (or (or (and x0 x9) (and x0 x0)) (or (or x3 x0) (and x3 x3))))) (not (not (and (or (or x2 x1) (and x5 x9)) (or (or x1 x1) (and x2 x5))))))) (and (not (or (and (not (or (or x4 x0) (and x6 x9))) (or (not (and x5 x5)) (and (and x0 x7) (or x7 x7)))) (not (not (not (not x9)))))) (or (and (or (and (and (and x2 x6) (and x6 x9)) (or (not x8) (and x3 x0))) (and (not (not x6)) (and (not x1) (or x3 x1)))) (not (or (and (and x8 x7) (and x0 x4)) (or (not x1) (not x0))))) (or (not (or (or (and x7 x1) (and x8 x7)) (and (or x3 x1) (or x6 x2)))) (and (not (not (not x0))) (not (and (or x2 x3) (or x5 x3))))))))))) +(check-sat) +(pop 1) +(assert (and x5 x7)) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(check-sat) +(push 1) +(assert (and (or (or (not (and (not (or (or (not x5) (not x2)) (and (and x5 x2) (not x2)))) (or (or (and (not x2) (or x2 x1)) (or (or x3 x1) (and x3 x6))) (not (or (or x0 x4) (or x5 x0)))))) (not (and (not (or (not (and x1 x3)) (not (and x5 x4)))) (not (or (or (or x6 x0) (or x5 x3)) (and (or x4 x5) (or x4 x0))))))) (not (or (not (and (not (or (or x0 x6) (and x2 x2))) (or (and (or x3 x6) (or x1 x5)) (and (not x3) (not x3))))) (or (not (and (and (and x2 x3) (not x0)) (not (not x2)))) (not (or (not (and x1 x2)) (not (or x6 x6)))))))) (not (not (not (not (and (and (or (and x4 x2) (and x4 x4)) (or (and x5 x5) (and x0 x4))) (not (not (or x4 x0)))))))))) +(check-sat) +(pop 1) +(assert (and (and (not (and (or (not (or (or (or (not x1) (and x6 x5)) (and (and x2 x3) (and x5 x1))) (and (not (not x4)) (and (and x4 x5) (not x1))))) (and (and (not (not (not x5))) (or (or (and x6 x3) (and x3 x6)) (or (not x2) (not x0)))) (and (or (or (or x6 x4) (and x6 x1)) (or (and x1 x6) (or x1 x0))) (or (and (not x6) (and x2 x2)) (not (and x2 x0)))))) (and (and (or (or (not (and x1 x6)) (and (not x0) (not x4))) (or (and (not x4) (not x4)) (and (or x4 x1) (and x2 x1)))) (or (or (not (or x6 x0)) (and (and x6 x5) (not x0))) (and (and (and x2 x2) (and x0 x0)) (or (or x0 x0) (and x3 x4))))) (not (and (not (not (and x1 x5))) (and (and (and x1 x3) (and x4 x2)) (or (or x5 x2) (and x5 x1)))))))) (not (and (not (not (and (and (or (and x6 x2) (and x3 x0)) (or (or x3 x5) (and x4 x4))) (not (or (or x2 x3) (and x5 x6)))))) (or (not (not (or (and (not x2) (not x4)) (and (not x1) (and x1 x2))))) (and (or (and (not (or x5 x5)) (not (or x3 x1))) (and (and (and x4 x3) (or x1 x0)) (and (and x0 x3) (or x3 x3)))) (or (not (not (or x0 x0))) (not (not (and x0 x0))))))))) (or (not (and (or (not (or (not (not (or x5 x5))) (not (not (or x2 x6))))) (and (and (and (not (not x4)) (not (or x2 x4))) (not (or (and x0 x5) (or x4 x1)))) (or (or (or (not x6) (and x5 x2)) (or (not x1) (and x5 x1))) (or (or (and x5 x3) (or x3 x5)) (and (not x1) (or x0 x0)))))) (and (and (not (not (and (or x3 x0) (and x1 x2)))) (not (not (or (or x6 x0) (not x5))))) (not (or (or (not (not x4)) (and (not x6) (or x1 x4))) (and (or (or x6 x0) (and x3 x5)) (not (not x0)))))))) (not (not (not (or (and (or (or (or x0 x2) (and x0 x0)) (or (and x6 x6) (not x6))) (and (or (not x3) (not x2)) (and (and x0 x3) (or x6 x5)))) (and (or (not (not x3)) (or (or x1 x0) (and x2 x6))) (not (not (and x0 x2))))))))))) +(assert (not x6)) +(assert (or (not (or (and (and (not (not (not x0))) (and (not (not x3)) (or (not x5) (not x6)))) (and (or (or (or x0 x4) (and x0 x6)) (or (not x3) (or x3 x3))) (and (and (not x6) (and x2 x6)) (or (or x5 x3) (and x4 x6))))) (or (and (not (and (or x1 x3) (not x5))) (or (or (and x1 x4) (not x2)) (or (not x5) (or x1 x3)))) (or (and (and (or x4 x3) (and x2 x2)) (or (and x4 x0) (not x5))) (or (or (and x4 x1) (and x3 x5)) (and (or x5 x1) (not x2))))))) (or (or (and (and (not (and (or x4 x0) (not x5))) (and (not (or x2 x1)) (and (and x0 x0) (or x2 x2)))) (or (or (not (or x2 x3)) (or (and x4 x2) (not x4))) (and (and (or x3 x2) (or x1 x4)) (not (not x6))))) (or (or (not (not (or x2 x0))) (not (not (and x0 x0)))) (not (not (and (or x6 x4) (and x3 x5)))))) (or (or (not (or (and (and x4 x1) (or x1 x1)) (and (not x0) (not x5)))) (not (and (not (and x4 x1)) (and (or x3 x0) (and x5 x3))))) (and (and (not (not (not x6))) (or (or (not x5) (or x2 x5)) (and (and x5 x3) (or x3 x1)))) (or (not (and (not x2) (not x5))) (and (or (not x3) (not x5)) (not (not x6))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (or (or (not (and (and x2 x5) (and x5 x0))) (not (or (and x0 x0) (or x3 x6)))) (not (not (or (or x5 x1) (and x4 x0))))) (and (not (or (and (and x3 x1) (or x1 x3)) (not (not x0)))) (not (and (or (or x0 x2) (or x4 x2)) (or (and x6 x1) (or x6 x1)))))) (not (not (not (or (or (or x1 x1) (or x3 x0)) (or (and x3 x2) (or x4 x4)))))))) +(assert (not (and (not (and (not (and (and (and (not x1) (not x2)) (not (and x4 x2))) (or (or (or x5 x6) (and x0 x1)) (and (or x1 x5) (not x3))))) (or (and (or (not (not x4)) (not (and x2 x0))) (and (and (or x5 x3) (or x5 x0)) (or (not x3) (or x1 x3)))) (and (or (or (not x1) (and x5 x2)) (not (or x1 x0))) (or (not (and x2 x1)) (or (not x1) (and x6 x2))))))) (and (not (and (and (and (not (not x1)) (or (or x6 x0) (not x5))) (and (and (and x4 x1) (and x4 x4)) (not (or x3 x1)))) (or (and (not (and x5 x4)) (or (or x2 x2) (not x6))) (or (not (and x0 x2)) (and (or x6 x2) (or x1 x2)))))) (and (or (or (not (and (or x0 x4) (not x1))) (not (or (and x2 x4) (and x2 x2)))) (or (and (not (and x4 x4)) (not (and x3 x3))) (and (or (and x1 x0) (not x0)) (or (or x5 x6) (not x0))))) (or (or (and (or (not x5) (or x4 x1)) (and (not x4) (and x3 x5))) (or (not (and x3 x1)) (or (or x6 x1) (not x3)))) (and (or (not (or x0 x1)) (and (and x3 x6) (or x1 x1))) (and (and (and x0 x6) (and x5 x0)) (or (not x4) (or x5 x0)))))))))) +(check-sat) +(push 1) +(assert (not (and (or (not (and (not (and (and (and x6 x2) (not x0)) (and (or x5 x6) (and x4 x5)))) (or (or (or (and x4 x1) (not x1)) (and (or x6 x3) (not x3))) (or (and (and x6 x3) (or x4 x4)) (not (or x3 x3)))))) (not (or (or (or (and (or x4 x1) (and x1 x2)) (or (and x5 x3) (not x1))) (not (not (or x3 x3)))) (not (not (and (not x4) (and x6 x0))))))) (or (not (and (and (or (or (not x6) (not x1)) (or (not x5) (not x4))) (and (not (or x6 x4)) (or (not x0) (or x1 x6)))) (or (and (and (or x3 x4) (or x1 x5)) (or (not x2) (or x4 x1))) (and (and (and x6 x0) (and x2 x4)) (and (and x4 x6) (not x6)))))) (or (or (and (not (not (and x4 x4))) (not (and (not x1) (or x2 x2)))) (or (not (or (not x1) (or x6 x0))) (and (not (and x4 x5)) (and (not x5) (and x5 x4))))) (not (or (or (and (not x5) (or x0 x6)) (not (not x0))) (not (not (or x0 x1)))))))))) +(check-sat) +(push 1) +(assert (or (not (or (or (and (and x4 x3) (or x1 x4)) (and (not x4) (and x2 x0))) (and (or (not x4) (and x6 x6)) (and (and x5 x5) (not x4))))) (and (or (and (or (and x6 x3) (and x0 x2)) (or (or x3 x1) (or x2 x1))) (or (or (not x0) (not x1)) (and (or x2 x0) (or x5 x6)))) (and (and (not (not x0)) (or (or x3 x1) (or x3 x3))) (not (and (and x3 x0) (and x3 x1))))))) +(assert (and (or (or (or (and x3 x0) (or x3 x4)) (not (or x5 x6))) (and (and (and x2 x3) (not x4)) (or (and x4 x0) (not x6)))) (not (and (not (not x2)) (or (or x2 x1) (or x0 x2)))))) +(assert (or (not (or (or (or (and (or (or (and (or x4 x2) (and x2 x3)) (and (not x4) (or x4 x5))) (not (not (and x1 x6)))) (not (and (or (and x3 x4) (and x4 x3)) (and (and x1 x6) (or x1 x4))))) (or (and (or (and (or x3 x0) (and x1 x5)) (and (or x2 x1) (or x2 x2))) (or (or (and x3 x4) (and x6 x1)) (or (not x5) (or x0 x2)))) (and (not (and (not x4) (not x1))) (and (or (not x5) (or x2 x6)) (or (and x6 x4) (not x5)))))) (or (and (not (or (and (or x4 x3) (not x2)) (or (or x6 x6) (and x4 x0)))) (or (or (and (or x6 x5) (or x3 x3)) (and (or x6 x4) (not x4))) (not (not (and x4 x3))))) (not (or (or (or (and x5 x4) (or x0 x6)) (or (not x6) (and x2 x3))) (and (or (not x1) (or x6 x5)) (and (and x0 x2) (or x6 x6))))))) (and (and (and (and (or (not (not x6)) (and (and x5 x3) (and x2 x4))) (not (not (not x0)))) (and (or (or (and x6 x4) (not x4)) (not (or x3 x3))) (not (or (not x2) (and x1 x5))))) (or (or (or (or (and x3 x2) (not x1)) (not (not x6))) (and (not (not x4)) (and (not x6) (not x4)))) (or (and (not (or x2 x0)) (or (or x2 x5) (or x3 x3))) (and (not (not x2)) (not (or x2 x5)))))) (and (or (or (and (and (and x0 x0) (and x2 x5)) (not (and x4 x2))) (or (not (and x1 x0)) (not (and x3 x0)))) (and (and (or (or x0 x3) (not x4)) (or (not x5) (not x5))) (or (or (or x6 x2) (and x0 x5)) (not (and x0 x1))))) (or (not (not (and (not x0) (or x1 x6)))) (and (or (or (or x5 x6) (or x1 x5)) (not (or x2 x5))) (or (or (and x4 x2) (not x1)) (or (and x0 x0) (or x2 x6))))))))) (and (and (and (not (or (not (or (or (not x6) (and x4 x2)) (or (not x4) (and x4 x6)))) (or (or (and (not x1) (and x6 x1)) (or (not x4) (and x4 x5))) (or (and (not x3) (not x0)) (or (not x3) (or x6 x2)))))) (or (or (not (and (or (or x6 x1) (or x0 x1)) (not (and x0 x1)))) (or (or (or (and x5 x2) (and x6 x1)) (not (not x3))) (not (or (and x3 x2) (not x0))))) (and (not (not (and (or x2 x3) (not x1)))) (not (or (or (not x3) (not x1)) (and (and x2 x6) (and x2 x1))))))) (and (or (or (or (and (and (not x5) (or x4 x1)) (and (or x3 x5) (not x3))) (not (or (not x0) (or x2 x6)))) (not (and (or (or x2 x2) (or x6 x6)) (and (and x4 x6) (and x2 x1))))) (or (or (and (and (not x0) (and x0 x2)) (and (and x0 x4) (not x0))) (not (and (not x0) (and x2 x0)))) (not (or (and (and x3 x1) (or x5 x2)) (or (or x4 x3) (or x4 x4)))))) (and (or (not (not (and (or x0 x4) (not x4)))) (and (or (or (or x5 x5) (or x0 x5)) (or (or x6 x4) (not x5))) (and (not (or x6 x0)) (and (or x2 x6) (or x0 x6))))) (and (or (not (not (or x2 x0))) (or (not (not x5)) (or (not x4) (or x5 x0)))) (and (or (or (or x0 x6) (not x4)) (not (or x2 x0))) (and (or (and x2 x3) (and x5 x5)) (or (and x4 x5) (not x2)))))))) (and (not (and (or (and (not (or (not x2) (or x6 x1))) (or (and (or x1 x3) (and x0 x5)) (or (not x5) (or x0 x5)))) (and (and (and (not x3) (or x2 x1)) (or (or x3 x0) (not x5))) (or (and (and x5 x6) (and x6 x2)) (or (not x1) (not x6))))) (not (not (not (not (not x0))))))) (or (not (not (and (and (or (not x3) (not x3)) (and (not x5) (not x5))) (not (not (or x0 x3)))))) (or (not (not (not (not (and x1 x0))))) (or (or (not (not (not x0))) (or (or (or x0 x2) (and x1 x3)) (or (and x6 x4) (and x6 x6)))) (and (not (or (and x4 x1) (and x4 x0))) (not (or (and x6 x6) (or x6 x4))))))))))) +(check-sat) +(pop 1) +(assert (and (and (and x5 x2) (and x2 x2)) (not (and x1 x1)))) +(check-sat) +(pop 4) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(assert (or (not (or (and (or (and (or x1 x0) (not x1)) (and (not x0) (not x0))) (and (not (not x1)) (not (or x1 x1)))) (and (and (or (or x0 x0) (not x1)) (and (not x0) (not x1))) (not (or (and x1 x1) (and x0 x1)))))) (or (not (and (or (not (and x1 x1)) (not (and x1 x0))) (not (not (and x0 x1))))) (not (or (and (and (and x0 x1) (and x0 x0)) (and (or x0 x1) (and x0 x0))) (not (not (and x0 x0)))))))) +(check-sat) +(push 1) +(assert (and (or (and (or (or (not (or (and (and (not x1) (and x0 x0)) (or (or x0 x1) (and x1 x0))) (and (and (or x1 x1) (or x1 x0)) (not (or x0 x0))))) (and (and (or (not (and x1 x0)) (and (not x0) (or x1 x0))) (and (not (or x0 x1)) (not (and x0 x1)))) (not (not (and (and x0 x0) (not x0)))))) (and (and (not (not (or (and x0 x0) (not x1)))) (and (or (and (and x1 x1) (not x0)) (not (and x0 x1))) (or (and (or x1 x1) (and x0 x1)) (not (not x1))))) (and (not (or (or (not x1) (or x0 x1)) (and (or x0 x1) (and x1 x1)))) (not (and (not (and x1 x0)) (not (not x1))))))) (or (or (not (or (or (or (or x0 x0) (or x1 x1)) (and (or x1 x1) (and x1 x1))) (or (not (not x1)) (not (and x0 x1))))) (or (or (and (not (or x1 x1)) (and (not x1) (and x0 x1))) (and (not (not x1)) (and (and x0 x0) (and x1 x1)))) (and (or (or (or x0 x0) (not x1)) (and (not x0) (or x1 x0))) (and (and (not x0) (and x0 x1)) (and (or x0 x1) (not x1)))))) (not (and (or (not (not (and x0 x1))) (and (not (or x0 x1)) (not (not x1)))) (and (not (and (or x1 x0) (not x0))) (and (or (or x0 x0) (or x1 x0)) (and (or x1 x1) (not x1)))))))) (not (and (not (or (and (and (or (or x0 x1) (or x0 x0)) (not (not x0))) (not (and (not x1) (not x0)))) (and (not (or (or x0 x0) (not x0))) (not (not (not x1)))))) (not (or (or (or (and (and x1 x1) (not x1)) (not (not x1))) (and (and (or x1 x1) (or x1 x0)) (and (and x0 x1) (or x0 x0)))) (not (or (not (or x1 x0)) (or (not x1) (or x0 x1))))))))) (not (and (not (and (or (and (not (or (not x0) (and x1 x1))) (and (or (not x0) (and x1 x0)) (not (not x1)))) (or (not (or (and x0 x1) (and x0 x0))) (or (not (and x0 x0)) (and (and x1 x0) (and x1 x0))))) (not (not (and (and (not x1) (not x0)) (and (not x0) (and x0 x0))))))) (and (or (and (or (or (and (or x1 x1) (and x1 x1)) (not (not x1))) (and (and (not x1) (or x1 x1)) (not (and x0 x0)))) (or (or (not (not x0)) (and (or x0 x1) (or x1 x0))) (or (and (not x1) (not x0)) (or (and x1 x1) (and x1 x0))))) (or (and (or (and (and x0 x0) (not x1)) (not (not x0))) (not (and (or x1 x1) (and x1 x0)))) (and (or (not (not x0)) (not (or x0 x1))) (and (or (or x1 x0) (and x0 x0)) (and (or x1 x0) (and x1 x1)))))) (not (not (or (and (or (or x1 x0) (and x0 x1)) (not (or x1 x1))) (and (and (not x0) (and x1 x0)) (not (or x0 x0))))))))))) +(assert (and (or (and (or (or (not (and x0 x1)) (not (or x0 x1))) (not (and (and x1 x1) (or x1 x1)))) (or (and (or (not x0) (or x0 x0)) (or (and x1 x1) (not x1))) (or (not (and x1 x0)) (and (and x0 x0) (or x0 x0))))) (not (or (or (not (and x1 x1)) (and (or x1 x0) (or x1 x0))) (not (or (or x0 x1) (and x1 x0)))))) (or (and (or (not (not (and x0 x0))) (and (and (or x0 x0) (and x1 x1)) (or (or x0 x0) (or x1 x0)))) (or (not (and (not x1) (or x1 x1))) (and (or (and x1 x0) (or x1 x0)) (not (or x0 x0))))) (or (or (and (and (or x1 x0) (and x1 x1)) (not (or x1 x0))) (and (or (not x1) (and x0 x0)) (or (or x0 x1) (or x0 x1)))) (and (and (and (and x1 x0) (or x0 x1)) (not (or x0 x1))) (and (or (not x1) (and x0 x0)) (and (or x1 x1) (and x0 x1)))))))) +(check-sat) +(pop 1) +(assert (not (not (not (or x0 x1))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (or (and (not (or (or (and (or (or x7 x2) (and x4 x1)) (or (or x0 x5) (and x1 x2))) (not (or (not x5) (or x8 x6)))) (not (or (or (not x0) (and x1 x1)) (not (or x4 x6)))))) (and (and (and (or (or (not x1) (or x3 x0)) (not (not x0))) (or (not (or x2 x7)) (or (and x2 x3) (and x0 x5)))) (or (and (not (and x3 x5)) (and (or x1 x7) (and x0 x7))) (not (and (not x2) (and x5 x0))))) (and (not (not (or (not x1) (or x0 x3)))) (and (not (and (or x2 x5) (and x5 x3))) (and (or (or x2 x5) (and x8 x6)) (or (not x2) (or x8 x6))))))) (or (or (and (not (and (not (or x4 x0)) (or (or x1 x6) (or x6 x0)))) (and (not (not (not x8))) (not (and (not x5) (and x2 x6))))) (not (not (or (not (not x8)) (not (and x7 x8)))))) (or (not (and (and (and (not x2) (not x5)) (and (not x1) (and x5 x0))) (not (not (and x5 x1))))) (and (not (or (not (not x0)) (not (and x8 x0)))) (not (or (or (or x8 x5) (not x8)) (and (not x4) (and x7 x0))))))))) (or (not (or (not (or (not (or (not (not x8)) (not (not x8)))) (and (and (not (not x6)) (not (or x1 x3))) (or (and (not x8) (and x6 x4)) (not (or x2 x1)))))) (not (or (or (and (and (not x4) (or x8 x7)) (or (and x0 x8) (and x4 x3))) (not (or (or x3 x7) (or x2 x5)))) (not (and (not (or x5 x1)) (not (not x8)))))))) (and (or (and (or (not (not (or (not x6) (or x0 x8)))) (and (and (and (not x5) (not x1)) (not (or x4 x4))) (and (and (not x3) (or x7 x6)) (not (or x8 x7))))) (not (and (or (not (and x8 x0)) (not (and x7 x6))) (and (and (or x0 x0) (or x3 x4)) (not (or x8 x5)))))) (and (or (not (or (not (or x5 x8)) (or (and x2 x2) (not x8)))) (or (not (not (not x0))) (or (and (and x1 x5) (not x3)) (or (and x1 x7) (not x2))))) (and (and (or (not (and x2 x7)) (not (or x7 x8))) (and (and (or x6 x1) (or x6 x4)) (not (and x3 x7)))) (and (or (not (or x7 x1)) (not (not x0))) (and (not (or x3 x6)) (not (not x7))))))) (or (or (not (not (and (not (or x4 x1)) (not (and x6 x3))))) (not (not (and (not (or x4 x7)) (or (and x5 x7) (and x2 x1)))))) (and (and (not (or (not (not x6)) (not (and x1 x3)))) (or (not (or (and x6 x4) (and x2 x2))) (or (or (or x7 x6) (not x3)) (and (and x3 x4) (not x7))))) (or (or (not (or (and x7 x4) (not x8))) (and (not (or x6 x5)) (and (and x6 x5) (and x4 x0)))) (and (not (or (not x4) (and x3 x8))) (and (not (not x8)) (not (not x4))))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (or (or (and (and (and (and (and x3 x7) (or x3 x2)) (or (and x7 x7) (and x6 x5))) (or (or (and x4 x5) (or x6 x6)) (and (and x4 x3) (and x5 x5)))) (and (and (or (or x5 x0) (and x8 x2)) (and (or x1 x6) (and x5 x0))) (or (not (and x8 x4)) (and (not x8) (or x0 x1))))) (and (or (or (and (not x8) (not x8)) (and (not x7) (and x8 x5))) (not (and (or x1 x3) (or x5 x0)))) (not (and (not (and x8 x1)) (not (not x2)))))) (and (or (and (not (not (or x2 x5))) (or (not (or x8 x8)) (and (not x6) (and x7 x8)))) (or (and (not (or x6 x2)) (and (not x1) (and x2 x2))) (not (or (or x6 x3) (and x6 x0))))) (not (or (or (not (or x1 x7)) (or (and x3 x6) (and x5 x6))) (and (or (not x0) (or x0 x2)) (or (not x2) (and x0 x8))))))) (not (or (or (not (not (and (or x5 x4) (or x4 x2)))) (and (not (or (or x1 x6) (not x8))) (or (not (not x3)) (and (or x4 x7) (and x2 x4))))) (and (not (not (or (or x0 x8) (not x4)))) (or (and (and (not x4) (and x2 x5)) (not (and x3 x5))) (and (not (or x0 x0)) (not (not x3))))))))) +(check-sat) +(pop 1) +(assert (or x3 x3)) +(check-sat) +(pop 1) +(assert (not (and (not (and (or x4 x1) (and x6 x3))) (and (not (and x3 x6)) (and (not x6) (and x5 x6)))))) +(assert (or (not (or (and (or (or (not (and x6 x7)) (or (not x8) (not x6))) (or (not (and x1 x8)) (or (not x6) (not x4)))) (and (and (or (not x4) (not x3)) (and (not x7) (and x4 x7))) (and (and (or x2 x7) (or x5 x2)) (and (not x1) (not x2))))) (not (not (or (and (and x5 x0) (not x1)) (and (and x4 x8) (not x1))))))) (not (and (not (or (not (or (or x7 x4) (not x1))) (not (not (not x2))))) (not (not (not (not (or x7 x7))))))))) +(check-sat) +(push 1) +(assert (or (and (not (or (and (or x8 x2) (and x3 x4)) (not (or x3 x4)))) (and (not (and (and x2 x4) (or x7 x1))) (not (not (or x7 x1))))) (and (not (not (or (and x5 x4) (or x2 x6)))) (and (or (or (and x1 x1) (or x2 x3)) (not (or x3 x1))) (or (and (or x6 x7) (or x2 x0)) (not (and x8 x0))))))) +(check-sat) +(pop 1) +(assert (and (or (not (and (or (or (or (and (not x0) (not x1)) (and (or x0 x2) (not x0))) (or (or (or x0 x0) (not x2)) (not (not x6)))) (and (not (and (or x5 x3) (not x5))) (not (or (and x1 x6) (and x0 x1))))) (and (or (and (and (or x6 x7) (and x6 x8)) (or (or x5 x7) (and x5 x3))) (not (not (not x7)))) (or (not (and (or x6 x3) (and x8 x3))) (or (and (and x6 x2) (and x3 x0)) (not (and x6 x0))))))) (and (and (and (or (or (and (and x3 x7) (or x0 x0)) (and (or x4 x4) (not x3))) (not (and (not x6) (and x7 x5)))) (and (or (not (or x1 x8)) (and (not x5) (or x8 x4))) (and (or (or x5 x1) (or x6 x3)) (not (not x2))))) (or (and (or (or (not x5) (and x2 x0)) (not (and x7 x1))) (and (and (and x1 x1) (not x6)) (or (not x0) (not x1)))) (and (or (and (or x8 x7) (and x1 x2)) (and (and x8 x0) (or x6 x7))) (not (not (or x6 x6)))))) (and (or (not (or (or (not x6) (or x1 x8)) (not (and x3 x3)))) (and (not (not (not x2))) (and (or (not x7) (and x5 x3)) (or (not x0) (and x5 x8))))) (and (and (or (not (and x1 x6)) (not (and x0 x4))) (not (or (or x8 x5) (not x8)))) (or (or (not (not x5)) (and (or x8 x1) (or x5 x4))) (or (and (and x4 x4) (not x3)) (and (or x1 x1) (and x7 x4)))))))) (or (and (and (or (or (not (and (not x8) (and x8 x0))) (not (and (and x4 x2) (not x2)))) (or (and (and (or x7 x6) (or x6 x7)) (not (and x1 x2))) (or (not (or x1 x6)) (not (not x3))))) (and (and (or (or (not x4) (not x5)) (or (or x1 x1) (and x5 x6))) (and (or (or x1 x8) (or x2 x0)) (and (not x4) (or x5 x4)))) (not (not (not (or x2 x4)))))) (or (not (or (or (or (and x8 x0) (or x4 x6)) (not (and x8 x0))) (and (or (not x2) (not x2)) (and (not x5) (not x2))))) (not (or (not (not (and x4 x8))) (not (not (or x1 x1))))))) (or (and (not (and (and (and (and x5 x5) (and x7 x6)) (or (and x1 x0) (and x1 x2))) (and (not (not x1)) (and (and x1 x0) (or x1 x8))))) (and (not (and (and (or x0 x2) (not x5)) (or (and x1 x3) (or x0 x2)))) (and (not (and (or x0 x3) (or x1 x1))) (not (or (or x6 x1) (or x5 x0)))))) (or (and (not (or (not (not x3)) (not (and x4 x3)))) (and (not (not (not x2))) (not (or (or x8 x2) (or x8 x2))))) (or (or (not (or (or x2 x0) (or x7 x0))) (and (or (or x4 x3) (not x7)) (and (and x7 x7) (not x1)))) (or (or (and (and x8 x8) (or x8 x0)) (or (not x0) (and x1 x7))) (or (not (or x1 x0)) (or (and x1 x3) (or x5 x3)))))))))) +(check-sat) +(push 1) +(assert (or (not (not (or (or (or x5 x4) (not x5)) (and (and x3 x7) (and x2 x7))))) (and (or (or (not (or x8 x6)) (not (not x1))) (not (not (or x5 x2)))) (or (and (or (and x5 x3) (not x3)) (or (not x8) (not x6))) (or (and (not x2) (not x8)) (not (not x8))))))) +(assert (and (and (and x1 x2) (or x4 x0)) (or (and x2 x6) (not x1)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (not (or (or (and (and (or (and (and x1 x1) (or x0 x0)) (not (and x5 x1))) (and (not (not x3)) (or (or x2 x4) (and x1 x2)))) (not (or (or (and x8 x2) (not x3)) (or (or x4 x1) (not x8))))) (or (or (and (and (not x8) (or x5 x0)) (or (not x3) (or x1 x2))) (and (and (and x6 x6) (not x5)) (not (not x6)))) (or (or (not (or x1 x7)) (or (and x6 x5) (and x5 x5))) (or (not (or x3 x6)) (or (or x8 x3) (and x4 x0)))))) (and (and (or (and (or (or x5 x8) (not x0)) (or (or x6 x2) (and x0 x3))) (and (not (and x1 x0)) (and (or x7 x4) (or x1 x7)))) (not (not (or (and x2 x3) (or x0 x6))))) (not (not (or (or (and x3 x5) (not x1)) (not (and x6 x4)))))))) (and (and (not (and (not (not (and (not x4) (and x1 x1)))) (or (not (and (or x2 x1) (or x0 x7))) (or (and (not x3) (and x0 x0)) (or (and x4 x1) (not x7)))))) (or (or (or (not (not (and x2 x1))) (and (or (and x5 x0) (and x5 x4)) (not (and x2 x6)))) (not (or (not (or x3 x2)) (not (and x1 x8))))) (or (not (or (and (not x8) (or x4 x8)) (and (not x0) (not x6)))) (not (and (and (and x2 x1) (not x8)) (and (not x6) (and x2 x8))))))) (or (not (not (or (and (or (not x7) (or x6 x0)) (not (not x8))) (or (and (not x0) (not x6)) (not (or x5 x2)))))) (not (or (and (not (and (not x5) (not x7))) (or (and (not x3) (or x4 x1)) (and (and x1 x1) (and x8 x2)))) (and (or (not (or x0 x6)) (not (or x8 x0))) (not (or (not x1) (or x5 x8))))))))) (or (and (or (and (and (and (or (or (or x2 x4) (not x8)) (and (and x5 x0) (not x6))) (and (and (and x2 x1) (or x8 x7)) (not (or x1 x2)))) (and (not (not (not x4))) (and (or (and x0 x0) (or x0 x8)) (not (not x3))))) (or (and (and (or (or x5 x8) (and x8 x5)) (or (not x2) (not x3))) (and (not (not x5)) (and (not x5) (or x6 x4)))) (not (or (or (not x6) (and x2 x7)) (or (or x8 x5) (not x2)))))) (or (and (or (or (not (or x6 x0)) (or (and x5 x4) (or x0 x0))) (or (and (or x6 x5) (not x1)) (and (not x7) (and x0 x4)))) (not (not (or (not x5) (and x0 x7))))) (not (and (not (not (not x2))) (not (or (or x0 x3) (and x3 x7))))))) (or (not (and (not (and (or (not x5) (and x4 x0)) (not (and x5 x1)))) (and (and (or (or x4 x3) (not x6)) (not (not x6))) (not (or (not x8) (or x0 x2)))))) (and (or (not (and (not (and x8 x7)) (and (not x6) (and x3 x8)))) (or (and (or (not x2) (or x6 x7)) (or (not x2) (not x1))) (not (not (not x2))))) (and (or (and (or (or x3 x6) (not x6)) (or (not x4) (and x2 x0))) (or (or (not x0) (and x6 x7)) (not (not x7)))) (and (not (and (and x5 x0) (or x2 x8))) (or (and (not x4) (and x8 x2)) (and (not x3) (not x2)))))))) (and (or (not (and (and (not (and (and x6 x5) (and x5 x3))) (or (and (and x7 x2) (or x4 x1)) (or (or x8 x0) (not x0)))) (not (and (not (not x0)) (not (and x2 x1)))))) (not (or (and (not (or (not x2) (not x5))) (or (or (and x3 x7) (or x4 x8)) (and (and x8 x1) (not x0)))) (or (not (not (or x0 x5))) (or (and (and x7 x0) (or x2 x5)) (not (and x0 x0))))))) (and (not (not (or (not (or (not x5) (not x6))) (and (not (and x4 x8)) (or (not x8) (or x3 x8)))))) (and (and (not (not (or (or x8 x8) (and x0 x4)))) (or (not (and (and x6 x2) (or x3 x6))) (and (not (and x6 x2)) (not (not x8))))) (or (or (and (and (not x5) (not x3)) (not (and x3 x7))) (and (not (and x4 x7)) (not (not x0)))) (or (not (or (not x6) (and x8 x6))) (not (or (not x8) (or x2 x1))))))))))) +(assert (or (or (or (not (and (and x4 x0) (or x0 x7))) (and (or (or x8 x3) (and x2 x0)) (and (and x4 x0) (and x1 x8)))) (not (or (or (not x8) (not x3)) (not (and x5 x7))))) (or (not (not (and (not x6) (and x8 x6)))) (or (or (or (and x7 x7) (or x7 x4)) (not (and x7 x3))) (or (and (not x8) (not x5)) (and (and x3 x4) (not x6))))))) +(assert (not (not (and (or x8 x1) (or x5 x7))))) +(check-sat) +(pop 1) +(assert (not (or (not (not (or (and (and (not (or x0 x1)) (not (and x5 x5))) (not (or (or x7 x4) (not x4)))) (and (not (not (or x6 x5))) (or (and (not x2) (and x6 x4)) (not (and x6 x8))))))) (not (and (or (and (or (or (and x0 x1) (not x5)) (not (not x8))) (and (and (and x4 x5) (or x8 x1)) (and (not x4) (and x4 x6)))) (not (not (or (and x4 x6) (or x7 x1))))) (not (not (or (not (not x8)) (not (and x6 x1)))))))))) +(assert (and (and x6 x5) (or x5 x0))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(assert (not (and (and (or (and (and (or (and (and x1 x1) (and x0 x0)) (or (and x1 x0) (or x1 x0))) (or (not (and x0 x0)) (or (or x0 x1) (or x0 x1)))) (not (and (not (and x1 x1)) (or (not x0) (not x0))))) (and (or (not (not (not x0))) (and (and (or x0 x1) (and x1 x0)) (not (and x1 x1)))) (or (not (not (not x1))) (or (or (and x1 x0) (not x1)) (not (and x0 x0)))))) (not (not (or (and (and (or x1 x0) (not x0)) (not (and x1 x0))) (and (or (not x0) (and x0 x0)) (and (or x0 x0) (or x1 x1))))))) (or (or (or (or (or (or (not x0) (and x1 x0)) (not (or x0 x0))) (and (not (or x0 x1)) (or (not x1) (not x0)))) (or (and (or (or x1 x0) (and x1 x0)) (not (and x1 x0))) (and (and (not x1) (or x1 x1)) (and (not x0) (and x0 x1))))) (or (and (or (or (not x0) (not x0)) (and (not x1) (and x1 x1))) (or (or (and x1 x1) (not x1)) (and (or x0 x1) (and x0 x1)))) (and (and (and (not x1) (not x0)) (or (or x0 x1) (or x1 x0))) (and (or (and x0 x0) (or x0 x1)) (or (or x1 x0) (and x1 x1)))))) (and (not (and (or (not (and x1 x1)) (or (and x0 x1) (not x1))) (not (and (not x1) (or x0 x0))))) (and (not (not (and (not x1) (not x0)))) (not (and (or (not x0) (and x1 x1)) (not (and x1 x0)))))))))) +(check-sat) +(push 1) +(assert (not (or (not (and (and (not (not (not (or (or x0 x1) (not x1))))) (and (and (and (and (not x0) (not x1)) (or (not x1) (not x1))) (and (and (not x1) (or x1 x0)) (and (and x0 x0) (or x0 x1)))) (or (and (not (and x0 x0)) (and (and x1 x1) (and x0 x0))) (and (not (and x0 x1)) (or (and x0 x0) (or x1 x1)))))) (not (and (or (and (not (or x0 x1)) (or (or x0 x0) (and x1 x1))) (and (not (or x0 x1)) (or (not x1) (and x1 x0)))) (and (and (not (or x1 x0)) (and (or x0 x1) (and x0 x1))) (not (not (not x1)))))))) (and (or (not (and (not (not (and (or x1 x1) (or x0 x0)))) (or (not (and (or x1 x1) (not x1))) (not (and (and x0 x0) (not x1)))))) (not (not (not (not (not (and x1 x0))))))) (and (not (not (or (or (or (and x0 x1) (and x0 x0)) (and (not x0) (or x1 x0))) (and (or (or x1 x1) (and x0 x0)) (or (not x0) (and x1 x1)))))) (or (not (and (and (or (not x0) (not x0)) (not (or x1 x0))) (or (and (and x1 x0) (not x0)) (or (or x1 x1) (and x1 x0))))) (and (not (not (and (or x1 x0) (and x0 x1)))) (and (and (not (and x1 x1)) (or (or x0 x1) (not x0))) (and (and (not x0) (not x0)) (or (and x0 x0) (or x0 x1))))))))))) +(assert (not (not (and (or (or (not x1) (or x0 x0)) (and (and x0 x1) (or x0 x0))) (not (not (and x0 x1))))))) +(assert (or (and (or x0 x1) (and x1 x0)) (or (and x1 x0) (not x0)))) +(assert (not (or x0 x0))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (and x0 x0) (and x0 x0)) (and (or x1 x0) (and x1 x0)))) +(assert (and x1 x1)) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (and (or x3 x1) (not x6))) +(check-sat) +(push 1) +(assert (or (or (or (not (not (or (not (not x6)) (or (and x3 x1) (not x4))))) (or (or (or (and (and x0 x1) (not x0)) (or (not x0) (and x0 x6))) (and (or (or x6 x0) (and x3 x1)) (or (or x3 x6) (and x4 x0)))) (not (not (or (not x4) (and x5 x3)))))) (and (not (or (not (and (or x1 x2) (and x1 x0))) (and (and (or x5 x0) (and x6 x2)) (and (and x4 x5) (not x3))))) (or (and (and (not (and x2 x0)) (or (or x1 x2) (and x2 x5))) (and (or (or x4 x3) (and x1 x3)) (not (not x5)))) (and (and (or (not x0) (not x4)) (or (or x5 x1) (or x3 x4))) (not (or (and x2 x4) (not x2))))))) (and (or (not (and (and (and (not x6) (and x1 x4)) (not (not x1))) (or (and (not x6) (or x2 x0)) (and (not x2) (or x0 x2))))) (not (and (not (or (or x6 x4) (or x2 x1))) (or (not (or x6 x4)) (or (not x5) (and x6 x2)))))) (or (not (not (or (and (not x4) (not x5)) (or (and x0 x6) (or x3 x3))))) (or (and (and (or (not x3) (or x2 x0)) (and (or x4 x5) (or x6 x1))) (not (or (and x5 x2) (not x4)))) (or (or (not (not x1)) (or (or x5 x4) (not x2))) (not (and (or x6 x4) (or x6 x1))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (not (and (or (or (not (or (or (and x3 x5) (or x6 x2)) (not (and x0 x4)))) (not (or (and (or x6 x0) (and x3 x2)) (not (not x3))))) (and (or (not (not (or x6 x2))) (and (and (or x0 x2) (or x6 x3)) (and (not x3) (not x6)))) (not (or (not (or x4 x4)) (not (not x0)))))) (not (not (not (or (not (and x2 x2)) (or (or x6 x4) (or x6 x2)))))))) (or (or (and (not (or (and (and (or x3 x3) (and x1 x0)) (or (not x6) (not x6))) (or (or (not x2) (not x2)) (or (not x6) (or x0 x5))))) (not (and (and (and (not x5) (or x0 x5)) (not (or x4 x3))) (not (and (and x3 x0) (and x3 x0)))))) (or (not (not (and (or (and x3 x0) (not x6)) (and (and x5 x6) (or x1 x0))))) (and (and (or (and (and x6 x0) (and x4 x1)) (or (or x4 x4) (or x0 x4))) (not (or (and x5 x6) (not x3)))) (or (or (not (not x4)) (and (not x2) (or x5 x5))) (and (or (and x0 x0) (not x4)) (and (or x2 x0) (not x6))))))) (and (not (or (or (and (not (and x4 x2)) (or (and x6 x2) (and x0 x1))) (and (or (not x3) (not x6)) (or (and x2 x3) (and x4 x3)))) (not (and (and (and x4 x0) (and x5 x0)) (not (or x0 x0)))))) (not (not (or (or (or (and x1 x1) (not x2)) (not (or x5 x0))) (or (or (or x2 x6) (and x4 x4)) (and (not x1) (and x3 x1))))))))) (and (or (and (or (or (not (and (or (and x0 x0) (and x0 x6)) (not (or x4 x5)))) (and (not (and (and x1 x3) (or x0 x5))) (or (not (not x5)) (not (or x4 x6))))) (and (not (not (not (and x4 x4)))) (or (or (and (not x2) (not x6)) (not (not x5))) (and (and (or x3 x5) (and x5 x1)) (not (or x4 x6)))))) (or (and (and (or (or (and x2 x5) (not x1)) (not (or x3 x5))) (not (or (or x1 x5) (and x6 x4)))) (or (or (and (or x1 x4) (or x3 x1)) (and (not x1) (or x5 x6))) (not (not (and x2 x4))))) (and (or (not (and (or x4 x3) (or x2 x0))) (not (or (and x3 x2) (or x0 x1)))) (not (not (not (and x1 x4))))))) (and (and (and (and (not (not (or x0 x3))) (and (not (or x0 x4)) (or (and x4 x3) (not x5)))) (or (or (not (not x1)) (and (and x4 x2) (or x1 x0))) (not (and (or x4 x4) (not x2))))) (or (or (and (or (and x4 x3) (or x2 x6)) (not (not x3))) (not (and (not x0) (or x4 x4)))) (or (and (not (or x3 x2)) (and (and x4 x0) (and x0 x1))) (or (not (or x0 x4)) (or (or x1 x2) (and x5 x0)))))) (not (not (and (and (and (not x4) (not x5)) (or (and x5 x0) (or x2 x5))) (not (or (not x3) (or x6 x3)))))))) (not (or (not (not (and (or (or (or x6 x3) (not x4)) (not (not x0))) (not (and (not x3) (not x2)))))) (not (or (or (not (and (not x6) (or x3 x0))) (not (or (not x1) (or x3 x0)))) (and (and (and (or x5 x2) (and x5 x2)) (or (not x4) (or x3 x0))) (and (and (not x0) (and x0 x0)) (and (not x6) (not x3))))))))))) +(assert (not (and (and (or (not (not (and (not (or x5 x2)) (not (not x6))))) (not (and (not (or (or x0 x5) (not x0))) (or (and (or x2 x2) (or x3 x6)) (or (or x4 x0) (and x0 x0)))))) (or (and (and (and (or (and x6 x0) (or x3 x6)) (and (or x2 x1) (or x6 x6))) (not (not (not x4)))) (not (or (not (and x6 x0)) (not (not x5))))) (or (and (not (not (not x6))) (and (not (not x1)) (and (and x2 x6) (or x2 x5)))) (and (not (and (or x4 x0) (and x4 x0))) (or (not (not x3)) (not (not x4))))))) (not (not (and (or (not (and (or x4 x1) (not x4))) (or (not (or x3 x6)) (not (or x0 x0)))) (not (or (not (not x2)) (and (not x4) (or x3 x1)))))))))) +(assert (or (or (not (not (not (not (not (and x2 x3)))))) (or (or (not (not (and (and x0 x2) (and x3 x4)))) (and (and (and (and x3 x3) (and x2 x2)) (not (or x0 x0))) (not (not (not x5))))) (and (not (or (not (or x6 x5)) (and (not x3) (and x5 x0)))) (and (not (not (not x4))) (not (not (and x5 x4))))))) (or (not (not (or (not (or (or x6 x5) (or x6 x1))) (or (not (or x2 x0)) (or (and x3 x6) (and x5 x3)))))) (or (or (or (or (not (not x4)) (and (and x0 x1) (and x3 x6))) (and (not (not x4)) (and (or x0 x3) (not x5)))) (not (not (not (and x2 x4))))) (not (and (not (not (not x5))) (and (and (or x2 x3) (not x1)) (not (and x4 x4))))))))) +(assert (and (and (or (or (not (not x2)) (and (not x3) (not x1))) (not (or (and x0 x0) (or x4 x4)))) (and (not (or (and x3 x3) (or x0 x0))) (and (and (or x5 x5) (or x2 x0)) (not (not x4))))) (not (and (or (and (and x4 x3) (not x6)) (not (and x5 x3))) (and (and (and x0 x4) (or x0 x3)) (and (not x1) (or x2 x1))))))) +(assert (not (or (not (and (and (and x6 x4) (not x5)) (not (and x4 x6)))) (and (or (or (and x2 x1) (and x3 x2)) (not (not x3))) (or (or (or x5 x0) (or x1 x3)) (and (and x3 x4) (or x4 x3))))))) +(check-sat) +(pop 1) +(assert (not (not (not (or x3 x2))))) +(check-sat) +(push 1) +(assert (not (and (not (and (and (or (or (not (not (and x4 x0))) (not (or (or x1 x2) (or x3 x1)))) (not (or (and (not x2) (and x4 x4)) (and (not x6) (not x4))))) (or (or (not (and (or x1 x5) (and x5 x5))) (not (or (or x5 x2) (or x1 x3)))) (not (and (and (not x3) (and x2 x5)) (or (or x3 x5) (and x4 x6)))))) (and (and (not (or (not (not x2)) (and (not x2) (and x4 x4)))) (not (and (and (not x5) (or x4 x0)) (not (and x5 x5))))) (or (not (not (not (not x1)))) (and (or (not (not x2)) (not (not x4))) (and (and (or x0 x1) (or x6 x4)) (or (not x4) (or x2 x3)))))))) (or (not (not (or (not (and (not (and x3 x4)) (not (not x6)))) (not (and (and (not x4) (or x1 x4)) (not (or x1 x5))))))) (and (and (not (or (or (and (or x5 x0) (or x3 x1)) (or (not x2) (or x0 x5))) (not (not (and x5 x4))))) (not (or (and (and (or x3 x3) (and x2 x6)) (and (and x3 x5) (and x1 x5))) (not (or (not x2) (not x0)))))) (and (and (and (or (and (or x3 x1) (or x6 x4)) (and (or x5 x3) (and x6 x1))) (or (and (or x2 x2) (or x6 x5)) (or (or x0 x0) (or x3 x5)))) (or (or (not (or x4 x4)) (and (and x0 x3) (and x5 x5))) (or (or (and x1 x3) (and x1 x5)) (and (and x1 x2) (or x2 x0))))) (or (and (or (and (or x0 x1) (not x4)) (and (not x4) (not x3))) (or (not (not x3)) (or (or x6 x4) (and x4 x4)))) (or (or (not (or x6 x5)) (and (or x2 x2) (and x2 x1))) (not (and (not x2) (or x1 x5))))))))))) +(assert (or x5 x5)) +(assert (or (or (not x5) (and x4 x3)) (not (and x1 x4)))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (and x1 x1)) (not (not x3)))) +(check-sat) +(push 1) +(assert (or (not (not x6)) (and (not x2) (or x6 x1)))) +(check-sat) +(pop 1) +(assert (or (not (not (and (not x3) (and x1 x4)))) (or (and (not (or x5 x0)) (not (or x1 x2))) (or (or (not x6) (or x3 x5)) (and (or x4 x5) (or x0 x6)))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (and (and x4 x3) (not x4)) (or (or x3 x5) (or x1 x6)))) +(assert (not (not (not (not (not (not x6))))))) +(check-sat) +(pop 1) +(assert (not (and (and (and (not (and x1 x1)) (or (and x5 x4) (not x1))) (not (and (or x0 x2) (or x0 x5)))) (not (and (and (or x0 x3) (and x4 x0)) (or (not x3) (not x1))))))) +(assert (and (or (not x3) (and x0 x2)) (not (not x2)))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (and (not (not (and (and (not x3) (not x2)) (not (not x1))))) (or (not (and (not (not x5)) (and (and x3 x3) (and x0 x2)))) (or (or (not (not x0)) (or (or x1 x5) (not x2))) (not (or (or x4 x5) (not x4)))))))) +(assert (not (or (not (not (and (not x5) (not x4)))) (or (and (and (and x5 x0) (not x2)) (and (or x1 x1) (or x3 x5))) (and (not (and x5 x0)) (or (not x0) (or x1 x2))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (and x4 x4)) (not (and x0 x4)))) +(check-sat) +(push 1) +(assert (or (not x2) (not x2))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (and (and (and x1 x0) (and x2 x5)) (or (and x3 x2) (or x1 x0))) (not (or (and x3 x1) (or x0 x1))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (and (or (and (or (not (and (or (and (not x1) (or x0 x2)) (and (not x3) (and x1 x1))) (not (or (not x0) (not x6))))) (and (not (and (not (and x6 x5)) (not (and x2 x3)))) (or (or (or (not x0) (and x4 x0)) (or (and x3 x3) (and x4 x1))) (and (not (and x1 x2)) (or (and x4 x3) (or x2 x0)))))) (or (and (and (not (and (and x5 x0) (and x4 x2))) (or (not (and x1 x5)) (and (not x0) (or x0 x0)))) (not (not (and (not x0) (and x6 x2))))) (not (and (or (and (or x5 x5) (and x3 x3)) (and (not x0) (or x5 x1))) (not (or (or x0 x0) (or x0 x2))))))) (or (or (not (not (and (or (or x0 x6) (and x2 x0)) (and (and x3 x1) (and x2 x4))))) (and (or (or (not (or x6 x3)) (or (and x0 x4) (or x5 x5))) (not (and (not x4) (not x3)))) (or (and (and (or x2 x6) (and x4 x6)) (and (not x6) (not x5))) (and (not (and x2 x5)) (or (and x0 x2) (or x5 x4)))))) (not (or (or (not (not (not x0))) (or (not (or x4 x1)) (not (not x4)))) (or (and (or (or x5 x6) (not x0)) (not (or x5 x3))) (and (and (or x3 x1) (or x3 x2)) (or (and x0 x4) (or x3 x1)))))))) (not (not (not (not (not (and (or (and x6 x1) (or x4 x4)) (and (not x0) (and x1 x2)))))))))) +(check-sat) +(push 1) +(assert (not (or (not (or x6 x1)) (and (not x0) (and x3 x0))))) +(assert (not (or (and (and (not (not x4)) (or (and x6 x1) (not x1))) (not (and (not x1) (and x5 x3)))) (not (not (not (not x2))))))) +(check-sat) +(pop 1) +(assert (or (not (not (and (and (and (or (or (not (and x0 x3)) (or (not x2) (not x5))) (or (and (not x1) (not x5)) (or (not x1) (and x3 x0)))) (and (or (or (or x4 x1) (not x4)) (or (not x1) (not x4))) (or (not (and x3 x4)) (not (not x1))))) (not (or (not (not (and x2 x2))) (not (or (and x3 x5) (not x0)))))) (and (and (or (or (and (and x5 x1) (or x6 x6)) (not (and x4 x3))) (or (not (not x6)) (and (not x3) (or x2 x3)))) (not (or (not (or x4 x5)) (not (not x6))))) (and (and (and (and (or x2 x2) (or x1 x4)) (or (and x4 x2) (not x3))) (or (not (not x6)) (and (and x1 x0) (or x2 x4)))) (and (not (or (and x1 x5) (or x4 x1))) (not (or (or x3 x2) (and x5 x4))))))))) (not (or (not (not (and (or (and (or (not x4) (or x5 x6)) (not (and x1 x4))) (and (or (or x5 x5) (not x0)) (not (and x1 x2)))) (not (and (and (not x2) (not x2)) (and (or x5 x4) (not x2))))))) (or (not (or (or (or (not (or x2 x1)) (and (and x6 x5) (not x2))) (not (or (not x6) (not x4)))) (not (not (and (not x4) (and x6 x0)))))) (and (or (and (or (or (and x6 x0) (not x0)) (and (or x6 x1) (not x3))) (and (not (or x6 x2)) (not (or x1 x2)))) (and (and (or (or x1 x2) (and x0 x3)) (not (and x0 x4))) (and (and (not x0) (not x1)) (or (not x2) (and x4 x1))))) (or (and (or (or (or x1 x0) (not x3)) (or (and x6 x0) (or x2 x0))) (not (not (and x5 x0)))) (or (and (or (and x5 x5) (or x0 x2)) (or (not x1) (or x0 x6))) (or (and (not x3) (not x3)) (or (not x0) (and x1 x5))))))))))) +(assert (or (not (or x6 x5)) (and (not x3) (or x1 x3)))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (or (not (or (or (or (not x0) (not x3)) (and (or x3 x5) (or x3 x1))) (not (or (not x4) (or x1 x5))))) (not (or (and (and (not x2) (and x5 x5)) (not (not x1))) (or (not (and x2 x4)) (not (or x0 x5))))))) (and (and (or (not (and (not (and x1 x0)) (or (not x1) (and x6 x4)))) (or (not (and (and x1 x5) (not x4))) (and (or (or x3 x3) (and x3 x6)) (not (not x3))))) (not (not (and (and (and x1 x0) (or x3 x5)) (and (or x3 x1) (not x5)))))) (or (and (or (and (or (or x2 x5) (not x5)) (or (or x1 x2) (and x0 x0))) (and (not (not x2)) (and (and x3 x5) (not x1)))) (and (and (not (not x3)) (and (or x0 x3) (and x2 x6))) (and (and (not x6) (or x1 x6)) (and (and x0 x5) (or x0 x0))))) (not (or (and (not (not x4)) (and (not x0) (and x1 x3))) (or (or (not x3) (and x6 x2)) (and (not x5) (and x0 x3))))))))) +(check-sat) +(push 1) +(assert (and (not (or (or (not (not x2)) (not (not x2))) (not (or (or x3 x6) (and x6 x4))))) (or (and (or (or (not x3) (not x6)) (not (not x5))) (not (or (or x4 x6) (and x3 x6)))) (not (not (not (and x3 x6))))))) +(assert (or (and x4 x1) (and x6 x3))) +(assert (not (and (not (not (and x3 x0))) (and (not (not x1)) (or (or x0 x6) (and x2 x5)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and x4 x3)) +(assert (not (or (not (not x5)) (and (and x6 x6) (or x1 x0))))) +(assert (not (and (and (not (or (not (not x6)) (and (and x0 x5) (or x2 x1)))) (or (not (or (or x6 x3) (or x1 x2))) (and (and (and x5 x5) (or x3 x6)) (not (or x0 x6))))) (not (and (or (or (or x2 x2) (or x4 x4)) (and (or x1 x1) (or x4 x5))) (not (and (and x5 x2) (or x3 x3)))))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(assert (and (not (not (and (not (not (or (or (or x2 x1) (and x5 x0)) (or (not x3) (and x4 x0))))) (or (or (not (not (not x1))) (and (or (or x5 x4) (or x2 x0)) (and (not x3) (and x3 x2)))) (and (not (or (or x2 x4) (not x4))) (or (or (not x4) (not x1)) (and (and x3 x3) (and x4 x3)))))))) (or (not (or (and (and (not (not (or x0 x4))) (and (or (not x2) (or x4 x1)) (and (and x3 x3) (or x0 x3)))) (not (and (and (not x0) (or x3 x4)) (or (and x2 x5) (and x4 x3))))) (not (or (not (not (not x5))) (and (or (and x2 x3) (and x4 x1)) (and (and x0 x3) (not x1))))))) (and (not (not (or (or (and (or x3 x3) (and x4 x5)) (or (or x3 x5) (not x4))) (and (and (or x5 x3) (and x0 x3)) (or (not x4) (not x4)))))) (and (or (or (and (and (and x1 x4) (not x4)) (or (not x1) (and x5 x4))) (and (or (not x2) (and x5 x4)) (or (or x1 x3) (not x5)))) (and (or (and (not x1) (or x3 x1)) (and (or x3 x0) (or x5 x1))) (not (not (or x4 x5))))) (or (or (not (or (and x3 x0) (or x4 x3))) (and (not (and x2 x4)) (not (not x0)))) (or (not (or (and x0 x4) (and x2 x4))) (not (or (not x5) (or x2 x4)))))))))) +(assert (and (and (or (or (not (and (or (or x4 x3) (and x1 x3)) (and (and x3 x3) (not x5)))) (or (not (or (not x2) (not x4))) (not (or (or x1 x3) (not x3))))) (or (not (or (not (or x4 x1)) (and (not x2) (and x1 x2)))) (not (not (and (and x3 x4) (not x2)))))) (or (not (not (or (not (or x5 x5)) (not (or x3 x5))))) (and (or (or (not (and x2 x2)) (and (or x1 x3) (or x3 x5))) (and (and (or x1 x1) (or x4 x0)) (not (or x0 x1)))) (and (and (not (not x4)) (or (not x2) (or x0 x4))) (or (and (and x4 x5) (and x5 x4)) (or (and x0 x0) (and x3 x4))))))) (and (or (not (or (not (or (not x5) (not x0))) (and (and (not x1) (not x0)) (not (not x5))))) (or (and (and (or (or x1 x2) (or x1 x0)) (not (or x2 x2))) (or (or (not x4) (not x3)) (not (or x1 x4)))) (not (or (and (not x2) (or x2 x0)) (not (or x3 x3)))))) (or (or (not (not (and (and x0 x2) (and x4 x5)))) (not (not (or (not x4) (or x0 x3))))) (or (or (not (or (or x5 x0) (or x5 x1))) (or (not (and x5 x5)) (and (or x3 x1) (not x0)))) (not (or (not (not x3)) (not (and x1 x5))))))))) +(assert (or (and (or (or x4 x1) (or x1 x2)) (and (and x5 x3) (and x0 x2))) (not (not (and x2 x2))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (or (and (not (and (and (not (or (or x3 x4) (and x0 x0))) (or (or (and x4 x3) (and x1 x2)) (and (and x4 x4) (or x2 x4)))) (and (and (not (not x5)) (not (not x5))) (not (not (not x4)))))) (not (and (and (not (not (not x1))) (or (or (not x5) (not x4)) (or (and x3 x1) (or x5 x3)))) (and (and (not (and x1 x1)) (or (not x5) (or x0 x1))) (not (and (and x1 x3) (or x0 x0))))))) (or (not (or (not (and (not (or x3 x0)) (not (or x5 x4)))) (or (and (and (or x2 x0) (not x2)) (or (and x5 x2) (not x1))) (or (not (not x2)) (not (not x5)))))) (not (or (not (or (or (or x0 x1) (or x3 x5)) (and (and x2 x3) (and x2 x3)))) (not (or (or (not x5) (not x2)) (not (and x4 x5)))))))) (or (not (not (not (and (or (or (not x1) (not x5)) (not (not x4))) (or (and (and x2 x4) (or x5 x1)) (or (and x4 x2) (and x3 x1))))))) (and (or (not (or (or (not (not x4)) (or (not x3) (not x2))) (not (not (and x0 x1))))) (or (not (not (or (and x4 x1) (or x2 x1)))) (not (or (not (or x3 x3)) (and (and x5 x1) (or x5 x4)))))) (and (not (or (or (and (and x3 x2) (not x3)) (and (or x2 x5) (not x5))) (not (or (and x2 x1) (or x4 x4))))) (and (or (or (or (and x3 x1) (not x3)) (not (not x5))) (and (or (not x1) (or x1 x3)) (not (and x2 x2)))) (and (or (and (and x1 x1) (or x5 x0)) (and (or x3 x5) (and x5 x1))) (and (not (and x4 x4)) (and (and x4 x5) (or x1 x2))))))))) (and (and (and (or (and (or (or (or (and x4 x0) (not x0)) (and (or x5 x5) (or x1 x5))) (or (not (or x2 x4)) (and (or x1 x4) (not x4)))) (and (or (or (and x2 x1) (not x3)) (and (and x3 x0) (and x5 x4))) (or (not (not x4)) (and (or x2 x3) (or x4 x4))))) (and (not (and (and (and x5 x4) (or x4 x4)) (and (not x1) (not x4)))) (or (and (not (or x0 x3)) (not (or x0 x2))) (and (not (not x1)) (or (and x4 x3) (not x2)))))) (not (not (and (not (not (and x0 x2))) (or (and (or x3 x0) (or x3 x0)) (or (and x4 x3) (or x0 x5))))))) (not (not (or (or (or (and (and x3 x4) (and x2 x3)) (and (and x1 x0) (and x3 x4))) (not (or (and x0 x2) (not x4)))) (or (not (and (or x3 x1) (or x4 x0))) (and (not (and x5 x3)) (or (not x4) (not x0)))))))) (or (or (and (and (not (and (not (or x5 x1)) (or (and x5 x1) (or x4 x2)))) (not (not (or (not x3) (and x4 x2))))) (not (not (and (and (not x5) (not x2)) (and (or x5 x5) (or x1 x2)))))) (not (and (and (not (not (not x3))) (not (not (not x0)))) (not (or (and (or x3 x3) (not x2)) (and (not x2) (and x2 x1))))))) (not (not (and (not (or (and (not x3) (or x2 x2)) (or (not x2) (not x2)))) (or (and (or (and x3 x3) (not x0)) (and (not x0) (and x0 x0))) (not (or (not x3) (or x4 x2))))))))))) +(check-sat) +(pop 1) +(assert (and (or (not (and (or (not (and (not (not x3)) (or (and x3 x4) (not x0)))) (not (or (and (not x0) (not x5)) (or (or x3 x4) (or x4 x1))))) (or (or (not (not (and x3 x1))) (or (or (and x0 x1) (not x1)) (or (not x5) (not x3)))) (and (and (or (or x0 x5) (or x2 x3)) (and (or x4 x1) (or x4 x1))) (not (and (or x3 x5) (and x1 x4))))))) (not (or (and (and (or (or (not x4) (not x5)) (and (or x2 x5) (not x5))) (or (or (not x2) (and x4 x3)) (or (or x1 x1) (or x0 x3)))) (and (not (and (or x0 x4) (or x0 x3))) (or (and (not x0) (or x5 x4)) (and (or x2 x4) (and x0 x2))))) (and (not (not (or (or x3 x4) (or x4 x4)))) (and (and (not (or x2 x3)) (and (or x1 x0) (and x1 x3))) (or (or (not x2) (and x3 x0)) (and (not x5) (and x3 x0)))))))) (not (not (or (and (or (or (and (or x1 x3) (and x2 x1)) (not (or x3 x1))) (not (and (not x4) (or x4 x5)))) (or (not (and (and x1 x2) (and x1 x1))) (not (not (or x5 x0))))) (or (and (not (not (or x1 x4))) (not (and (or x1 x3) (or x3 x0)))) (not (not (and (and x0 x2) (or x0 x1)))))))))) +(assert (and (and (or (and (not (and (or (and (or x4 x2) (not x3)) (and (not x2) (and x0 x5))) (not (not (and x5 x4))))) (or (not (not (or (and x4 x4) (or x3 x1)))) (not (or (not (not x2)) (or (not x3) (not x2)))))) (and (not (or (and (or (not x4) (or x2 x1)) (not (not x1))) (and (or (or x4 x5) (or x1 x4)) (not (not x2))))) (or (not (not (not (not x5)))) (not (and (not (not x0)) (or (not x3) (or x5 x4))))))) (or (and (or (not (not (or (and x2 x4) (not x1)))) (not (or (or (not x2) (not x1)) (not (not x4))))) (or (not (and (not (or x4 x5)) (and (or x3 x5) (and x1 x2)))) (and (not (or (and x1 x3) (not x3))) (or (or (or x2 x0) (and x2 x4)) (or (or x3 x1) (or x4 x5)))))) (not (or (not (or (not (and x5 x4)) (or (or x1 x2) (and x5 x5)))) (not (or (not (not x4)) (not (and x0 x1)))))))) (and (and (not (and (and (and (or (and x4 x1) (or x5 x3)) (or (or x3 x3) (or x3 x2))) (or (not (and x3 x5)) (and (and x5 x2) (or x4 x2)))) (and (or (or (and x2 x3) (or x5 x2)) (or (not x0) (not x5))) (and (not (not x5)) (or (not x5) (not x4)))))) (not (and (not (not (and (not x0) (or x2 x2)))) (and (or (not (or x3 x5)) (not (not x1))) (not (and (and x5 x1) (and x2 x1))))))) (not (and (not (or (or (and (or x0 x2) (and x1 x1)) (or (or x2 x4) (or x5 x5))) (or (or (and x4 x0) (or x5 x5)) (not (not x1))))) (and (and (or (or (and x1 x4) (and x2 x5)) (not (and x0 x0))) (and (or (and x1 x4) (and x2 x1)) (or (and x1 x1) (and x5 x4)))) (or (or (not (and x1 x1)) (or (and x3 x2) (and x0 x5))) (not (and (or x4 x5) (and x3 x1)))))))))) +(assert (not (and (and (and (or x3 x0) (and x1 x5)) (and (or x4 x2) (and x3 x4))) (or (and (and x2 x0) (or x2 x2)) (or (not x0) (and x3 x4)))))) +(check-sat) +(push 1) +(assert (not (not (not (and (or (and (and (or (not (or x3 x0)) (and (and x1 x2) (and x1 x1))) (not (not (or x5 x1)))) (and (and (and (not x5) (and x2 x5)) (and (or x4 x2) (and x2 x3))) (or (or (or x1 x5) (not x2)) (and (and x2 x0) (or x4 x4))))) (or (or (not (and (and x3 x1) (or x5 x4))) (not (not (or x2 x1)))) (or (not (not (and x5 x2))) (or (not (not x3)) (and (and x3 x4) (not x1)))))) (not (not (not (and (not (not x3)) (or (not x2) (or x2 x3))))))))))) +(assert (and (not (and (or (or (or (and (not x4) (and x2 x2)) (or (and x3 x2) (and x0 x1))) (not (or (and x3 x4) (not x3)))) (and (and (or (and x0 x4) (and x1 x5)) (and (or x4 x2) (and x3 x4))) (and (or (not x4) (or x1 x3)) (not (not x0))))) (not (or (and (and (or x1 x0) (and x0 x0)) (or (and x5 x3) (or x2 x5))) (not (and (or x4 x3) (not x0))))))) (not (or (not (not (not (and (or x2 x1) (not x1))))) (not (or (not (or (or x3 x0) (or x3 x1))) (or (or (or x3 x5) (not x1)) (not (and x5 x5))))))))) +(check-sat) +(pop 1) +(assert (or (or (and x5 x2) (or x1 x1)) (or (not x5) (or x3 x2)))) +(assert (or (not (and (or (and x0 x5) (and x4 x5)) (or (not x4) (not x0)))) (not (or (not (not x4)) (or (not x5) (and x4 x2)))))) +(assert (not (or (not (or (not (or x1 x1)) (and (and x2 x5) (or x2 x5)))) (not (or (or (not x0) (and x5 x4)) (not (and x1 x3))))))) +(assert (not (or (and (or (not x1) (or x0 x2)) (and (and x1 x1) (and x2 x4))) (and (not (not x5)) (not (not x0)))))) +(assert (not (or (or (or (and x1 x2) (not x0)) (and (not x2) (and x0 x2))) (and (not (and x2 x4)) (and (and x5 x0) (or x2 x4)))))) +(assert (or (or (or x3 x0) (or x0 x0)) (and (not x0) (not x1)))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(check-sat) +(push 1) +(assert (not (or (not x1) (or x1 x0)))) +(assert (and (and x2 x1) (not x0))) +(assert (not (not (or (not (and (not x2) (or x2 x3))) (not (and (not x2) (and x3 x3))))))) +(assert (and (not (and (not x3) (not x0))) (and (not (or x3 x3)) (or (not x2) (or x0 x1))))) +(assert (and (not (and (not (not (and (and (or (and x0 x0) (and x1 x0)) (or (or x2 x1) (and x1 x1))) (and (or (or x0 x3) (and x1 x0)) (not (and x0 x3)))))) (or (and (not (not (not (or x2 x3)))) (not (and (and (or x2 x1) (not x3)) (and (or x1 x1) (or x3 x1))))) (and (and (and (not (and x2 x3)) (or (or x3 x3) (or x2 x2))) (not (not (or x2 x2)))) (and (and (or (and x0 x0) (and x1 x1)) (not (or x3 x0))) (and (or (or x3 x3) (and x3 x2)) (or (not x0) (not x0)))))))) (not (or (or (and (and (not (or (not x1) (or x3 x3))) (and (and (not x0) (and x1 x3)) (and (and x3 x1) (not x2)))) (and (or (and (not x1) (not x1)) (and (not x1) (or x0 x2))) (not (and (or x1 x1) (and x2 x2))))) (or (or (and (or (or x3 x1) (and x1 x3)) (or (not x3) (not x3))) (or (or (not x0) (not x1)) (and (and x3 x2) (or x0 x3)))) (not (or (not (or x1 x0)) (or (and x3 x3) (or x0 x2)))))) (and (not (or (not (not (and x2 x3))) (not (not (and x1 x3))))) (or (not (and (or (and x0 x3) (or x0 x0)) (not (not x2)))) (not (and (not (and x3 x3)) (not (and x1 x2)))))))))) +(assert (not (or (not (or (not (and (and (and x1 x2) (not x1)) (or (or x1 x1) (or x3 x3)))) (not (or (not (not x3)) (and (and x3 x0) (or x3 x3)))))) (not (and (not (and (or (and x3 x2) (and x1 x0)) (not (not x2)))) (or (not (not (or x3 x1))) (or (not (not x2)) (and (or x1 x2) (and x1 x1))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (or (and (or (not x1) (not x2)) (and (or x1 x1) (and x0 x2))) (not (not (not x0)))) (or (or (not (or x1 x2)) (and (not x3) (or x0 x2))) (not (or (not x2) (or x3 x1)))))) +(check-sat) +(push 1) +(assert (not (not (and x2 x0)))) +(assert (not (and (and (and (not (and (or (or x0 x3) (not x0)) (not (and x3 x0)))) (and (or (and (and x3 x2) (not x2)) (and (not x1) (or x1 x3))) (and (or (not x3) (or x3 x3)) (and (or x0 x2) (not x0))))) (or (and (not (not (not x2))) (or (and (and x1 x0) (or x3 x1)) (and (or x3 x0) (not x0)))) (and (not (not (and x2 x2))) (and (not (and x0 x2)) (not (or x2 x1)))))) (or (or (not (not (and (and x3 x3) (or x1 x0)))) (or (not (not (or x0 x0))) (or (not (not x1)) (or (not x3) (not x2))))) (not (and (and (and (or x0 x1) (and x0 x0)) (not (and x3 x1))) (not (and (and x0 x0) (not x1))))))))) +(check-sat) +(pop 1) +(assert (not (not (or (and (or x0 x2) (not x1)) (and (or x2 x0) (not x2)))))) +(assert (and (or (and (not x0) (not x2)) (not (not x3))) (or (not (or x0 x0)) (and (not x0) (and x2 x3))))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(assert (or (not (or (not (not x0)) (and (or x1 x0) (not x0)))) (and (and (or (and x1 x1) (and x0 x1)) (not (not x1))) (or (not (or x0 x1)) (or (not x1) (or x0 x0)))))) +(check-sat) +(push 1) +(assert (or (not (and (and (or (not (not (and x1 x1))) (not (and (or x1 x0) (or x0 x1)))) (or (not (and (not x0) (and x0 x0))) (and (and (or x1 x0) (and x1 x1)) (not (not x1))))) (not (and (or (or (and x1 x0) (and x1 x1)) (not (or x1 x1))) (and (not (not x0)) (not (or x1 x1))))))) (and (not (and (or (and (and (not x0) (not x0)) (or (or x0 x1) (or x0 x1))) (not (and (or x1 x0) (and x1 x0)))) (and (not (or (not x1) (not x1))) (not (or (or x0 x1) (and x0 x0)))))) (not (or (and (or (and (and x0 x1) (or x1 x0)) (or (or x0 x1) (or x1 x1))) (and (not (not x1)) (and (not x1) (not x1)))) (not (or (not (or x0 x0)) (and (or x0 x1) (or x0 x0))))))))) +(assert (not (not (not x0)))) +(assert (or (not (or (or (or (not (not (or (and (not x0) (or x0 x1)) (or (not x0) (and x1 x1))))) (not (or (and (not (or x1 x0)) (not (not x0))) (not (or (and x0 x0) (not x0)))))) (and (not (not (or (or (or x1 x1) (and x1 x1)) (or (and x1 x0) (and x0 x0))))) (not (or (and (not (and x0 x0)) (not (not x0))) (or (and (not x1) (not x0)) (or (or x0 x1) (or x1 x0))))))) (and (and (and (and (and (not (or x1 x1)) (and (not x0) (not x0))) (not (and (or x1 x1) (not x0)))) (and (not (and (and x0 x0) (or x1 x1))) (not (not (not x1))))) (or (and (or (or (not x0) (or x0 x1)) (not (and x1 x0))) (and (or (or x1 x0) (and x0 x0)) (and (and x0 x1) (or x0 x1)))) (not (not (not (or x0 x0)))))) (and (not (not (and (not (or x0 x0)) (and (not x0) (not x1))))) (and (or (and (or (not x0) (and x1 x0)) (and (and x1 x0) (or x0 x0))) (or (not (not x0)) (and (not x0) (or x0 x1)))) (and (and (not (or x1 x0)) (or (or x0 x1) (and x1 x0))) (and (or (and x1 x1) (not x1)) (or (or x1 x0) (or x0 x0))))))))) (or (and (and (not (not (or (and (not (not x1)) (and (or x1 x1) (and x1 x1))) (or (or (and x0 x1) (or x0 x0)) (or (not x0) (and x1 x1)))))) (not (and (not (and (or (or x1 x0) (not x0)) (not (not x1)))) (not (and (or (or x0 x0) (and x1 x1)) (not (or x1 x1))))))) (or (and (not (not (not (not (and x0 x1))))) (not (not (or (and (not x0) (or x0 x1)) (or (not x0) (or x0 x0)))))) (not (or (and (and (and (and x0 x1) (or x0 x1)) (or (not x0) (or x1 x0))) (not (and (and x1 x1) (and x0 x1)))) (not (not (not (or x0 x1)))))))) (not (and (or (not (not (or (not (and x0 x1)) (or (not x0) (and x0 x1))))) (and (not (not (or (or x0 x0) (or x1 x0)))) (or (or (or (or x0 x0) (and x1 x1)) (and (or x0 x1) (not x0))) (not (and (not x1) (and x1 x0)))))) (and (and (and (not (or (and x1 x0) (not x0))) (not (not (and x1 x1)))) (not (not (or (and x1 x1) (or x0 x1))))) (not (and (and (and (or x0 x0) (and x1 x1)) (not (not x0))) (not (or (and x0 x1) (and x0 x0))))))))))) +(check-sat) +(pop 1) +(assert (or x0 x1)) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (or (and (and (and (and (and x0 x1) (and x1 x1)) (or (not x1) (not x0))) (and (or (not x1) (and x0 x1)) (not (and x0 x0)))) (and (not (not (or x1 x0))) (and (not (or x0 x0)) (and (and x1 x1) (and x1 x0))))) (not (not (not (not (not x0))))))) (not (and (not (and (or (not (and x0 x0)) (or (not x1) (not x1))) (or (or (and x0 x0) (and x0 x0)) (or (or x0 x1) (or x1 x0))))) (or (not (not (and (and x0 x1) (or x0 x0)))) (or (or (or (and x1 x0) (not x1)) (and (or x0 x0) (or x0 x0))) (and (and (or x1 x0) (or x0 x0)) (or (or x0 x1) (not x0))))))))) +(check-sat) +(push 1) +(assert (or (not (or (or (not (or (not (or (and x1 x1) (not x1))) (or (and (or x0 x0) (not x0)) (not (not x1))))) (and (not (or (and (not x0) (or x1 x1)) (and (not x0) (or x1 x1)))) (and (not (not (and x0 x1))) (and (not (not x1)) (or (not x1) (not x0)))))) (not (and (not (not (or (and x1 x0) (and x1 x0)))) (or (not (or (and x0 x0) (not x0))) (and (not (and x1 x1)) (not (not x1)))))))) (and (and (and (and (or (not (and (or x1 x0) (not x1))) (and (and (and x0 x0) (not x0)) (and (or x1 x1) (and x0 x0)))) (and (and (not (not x0)) (not (or x1 x0))) (or (or (not x0) (and x1 x1)) (not (not x0))))) (not (not (not (not (not x0)))))) (not (not (or (and (or (and x0 x1) (and x1 x0)) (or (not x1) (not x0))) (not (and (and x0 x1) (or x1 x1))))))) (or (or (or (or (not (or (not x0) (or x0 x0))) (and (not (or x1 x1)) (not (not x1)))) (not (or (and (or x1 x1) (not x1)) (and (not x0) (and x0 x1))))) (not (and (not (or (or x1 x1) (or x1 x1))) (not (or (not x0) (or x0 x1)))))) (or (or (and (or (or (not x1) (not x0)) (or (and x0 x1) (not x1))) (not (or (not x0) (not x1)))) (and (not (or (and x0 x0) (or x1 x0))) (or (not (not x0)) (or (or x1 x0) (not x0))))) (not (not (and (and (and x1 x0) (and x1 x0)) (and (not x1) (and x0 x0)))))))))) +(assert (not (or (or (or (not (and (or (not x0) (and x1 x1)) (and (and x1 x1) (or x1 x0)))) (and (or (not (or x0 x0)) (and (or x1 x0) (not x0))) (not (or (or x0 x1) (not x1))))) (or (not (and (and (not x0) (or x1 x1)) (or (or x1 x0) (and x1 x1)))) (or (and (not (and x1 x1)) (not (and x0 x0))) (not (and (not x1) (and x1 x0)))))) (or (and (and (and (not (and x1 x0)) (and (not x0) (or x0 x1))) (and (or (and x0 x1) (or x0 x0)) (not (not x1)))) (or (not (or (not x0) (not x1))) (or (and (and x0 x1) (and x1 x0)) (or (or x1 x0) (or x0 x1))))) (not (or (and (or (not x1) (or x0 x0)) (and (and x0 x0) (or x0 x1))) (not (and (and x1 x1) (not x0))))))))) +(check-sat) +(push 1) +(assert (or (and (or (or x0 x0) (or x1 x0)) (or (not x0) (or x0 x0))) (and (not (or x1 x0)) (not (not x1))))) +(assert (or (or (and (and (and x0 x1) (not x0)) (and (and x0 x1) (or x0 x0))) (or (or (or x1 x1) (and x0 x0)) (not (not x1)))) (not (or (not (not x0)) (not (or x1 x0)))))) +(check-sat) +(push 1) +(assert (or (or (not (not (and (not (not x0)) (or (or x0 x1) (and x0 x1))))) (and (not (and (and (or x1 x0) (and x1 x0)) (not (not x0)))) (not (and (and (and x0 x0) (and x1 x1)) (and (or x1 x0) (not x0)))))) (and (not (not (or (and (and x1 x0) (not x1)) (or (and x1 x1) (or x1 x0))))) (not (or (and (and (not x0) (not x1)) (or (and x1 x0) (or x1 x0))) (and (or (not x1) (not x1)) (or (not x1) (or x1 x0)))))))) +(assert (or (and x1 x1) (not x0))) +(check-sat) +(pop 1) +(assert (or (or (or (and (not (and (or (and x1 x1) (and x1 x1)) (and (and x0 x0) (not x0)))) (not (and (not (or x0 x0)) (or (not x1) (not x0))))) (not (or (and (not (and x1 x0)) (not (or x1 x1))) (not (or (not x1) (not x0)))))) (and (not (not (or (or (or x0 x0) (not x1)) (and (or x0 x1) (or x1 x1))))) (not (not (or (or (not x1) (not x0)) (or (not x0) (not x1))))))) (or (and (and (and (not (and (and x0 x1) (and x0 x0))) (and (or (and x0 x1) (not x0)) (or (not x1) (or x1 x0)))) (or (and (not (and x1 x0)) (and (or x0 x1) (or x1 x1))) (and (or (not x1) (not x0)) (not (or x0 x1))))) (not (or (or (or (not x1) (not x0)) (not (and x0 x1))) (or (not (not x0)) (or (or x1 x0) (and x0 x0)))))) (not (and (not (and (and (or x1 x0) (not x0)) (or (or x0 x0) (not x0)))) (and (not (or (not x0) (or x0 x0))) (and (or (and x0 x1) (or x0 x0)) (not (and x1 x1))))))))) +(assert (or (and (or (and (or (and (and (or x1 x0) (not x1)) (and (and x0 x1) (not x0))) (not (or (and x1 x0) (or x0 x1)))) (and (or (not (or x0 x0)) (not (not x0))) (not (or (not x0) (or x0 x0))))) (and (not (and (and (and x1 x0) (or x1 x0)) (and (or x1 x1) (not x1)))) (not (not (not (and x1 x0)))))) (and (not (and (not (and (or x1 x1) (or x0 x0))) (not (or (or x1 x1) (and x0 x0))))) (and (or (not (not (not x0))) (not (not (or x0 x0)))) (and (or (and (or x0 x1) (and x1 x1)) (and (not x1) (and x1 x0))) (and (or (and x0 x0) (not x0)) (or (not x1) (not x0))))))) (and (not (and (or (not (and (and x0 x0) (not x0))) (not (or (and x1 x1) (not x0)))) (or (not (or (not x1) (not x0))) (or (not (and x0 x0)) (and (or x0 x1) (and x1 x1)))))) (not (not (and (not (not (or x1 x1))) (not (not (or x1 x0))))))))) +(assert (not x0)) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(pop 3) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(assert (not (not (not (and (not (or (or (or (and x8 x3) (not x7)) (and (and x4 x3) (not x8))) (or (or (and x2 x7) (and x8 x0)) (and (or x2 x2) (or x8 x2))))) (or (not (or (or (or x5 x6) (or x8 x3)) (not (and x7 x6)))) (and (and (and (and x8 x1) (not x4)) (or (and x2 x7) (and x4 x2))) (and (and (not x3) (not x5)) (and (not x3) (or x5 x6)))))))))) +(assert (and (and (not (or (or (not (not (and (not x1) (or x6 x3)))) (not (not (or (and x4 x8) (and x5 x4))))) (and (and (and (not (not x7)) (or (not x2) (or x4 x5))) (or (not (and x1 x5)) (or (not x2) (not x4)))) (and (not (and (not x6) (or x7 x0))) (or (or (and x2 x8) (and x0 x0)) (and (and x3 x3) (and x4 x3))))))) (not (not (not (or (or (and (or x1 x3) (not x0)) (not (not x7))) (not (or (and x2 x5) (and x8 x5)))))))) (not (not (or (and (or (or (not (or x1 x2)) (not (or x6 x3))) (not (or (and x0 x4) (and x3 x4)))) (or (not (and (not x2) (not x4))) (and (not (not x8)) (not (or x6 x0))))) (or (or (or (not (and x7 x0)) (and (and x8 x6) (and x3 x8))) (not (and (or x8 x4) (or x8 x4)))) (and (not (or (or x7 x2) (and x2 x0))) (not (and (or x7 x8) (or x6 x7)))))))))) +(check-sat) +(push 1) +(assert (or x8 x2)) +(assert (not (and (and (or (not (not (not (and x3 x3)))) (or (not (not (not x4))) (and (or (not x1) (or x8 x7)) (not (and x3 x7))))) (or (not (or (not (or x1 x7)) (or (and x0 x2) (and x1 x4)))) (not (not (or (and x5 x2) (and x3 x3)))))) (not (and (or (or (or (not x4) (and x0 x6)) (or (not x1) (not x1))) (and (and (not x8) (or x1 x3)) (or (and x1 x7) (and x2 x0)))) (and (not (not (not x5))) (or (or (not x1) (or x5 x5)) (and (not x7) (or x1 x5))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and x0 x2)) +(check-sat) +(pop 1) +(assert (not (or (not (not x3)) (or (not x8) (and x8 x6))))) +(check-sat) +(pop 4) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(check-sat) +(push 1) +(assert (and (or (and (and (not (or x2 x1)) (not (or x5 x3))) (or (and (not x3) (or x1 x3)) (or (and x1 x0) (and x5 x0)))) (and (not (or (not x5) (not x0))) (not (and (or x5 x0) (and x4 x2))))) (and (not (not (not (not x0)))) (or (and (not (or x2 x3)) (and (or x0 x2) (not x2))) (or (not (not x3)) (or (and x1 x3) (and x2 x2))))))) +(check-sat) +(push 1) +(assert (not x1)) +(check-sat) +(push 1) +(assert (or (or (and (and (or (not (not x3)) (not (and x4 x2))) (and (and (or x4 x3) (and x2 x3)) (or (or x3 x5) (and x2 x5)))) (and (and (not (or x2 x4)) (not (or x5 x1))) (not (not (and x1 x0))))) (and (and (or (and (not x1) (not x4)) (not (and x5 x3))) (and (and (or x0 x3) (not x4)) (or (and x0 x0) (not x5)))) (not (not (not (and x2 x4)))))) (or (or (and (not (not (or x5 x4))) (or (or (and x0 x5) (or x3 x3)) (or (not x5) (and x4 x5)))) (and (and (not (and x4 x0)) (or (or x4 x3) (and x0 x3))) (or (or (or x5 x0) (and x1 x4)) (or (and x1 x5) (or x1 x4))))) (and (or (not (and (and x2 x3) (not x2))) (and (and (or x1 x2) (or x3 x1)) (and (and x4 x5) (not x3)))) (or (and (not (not x3)) (not (and x5 x2))) (and (and (or x0 x4) (and x3 x0)) (not (and x5 x4)))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (not (or (not x0) (not x4))))) +(assert (not (not (and (and x0 x0) (not x0))))) +(check-sat) +(pop 1) +(assert (or (or (not (and (or (or (and (and (or x1 x1) (not x5)) (or (or x1 x5) (and x4 x1))) (or (or (or x0 x1) (or x4 x1)) (and (or x1 x4) (and x1 x1)))) (not (not (or (or x0 x2) (and x0 x2))))) (not (and (and (not (not x0)) (not (and x1 x2))) (not (not (and x4 x3))))))) (not (not (and (not (and (or (or x3 x3) (and x3 x3)) (or (not x2) (or x4 x3)))) (not (and (or (or x0 x4) (and x1 x2)) (or (not x0) (and x1 x0)))))))) (or (and (and (not (not (and (or (or x5 x4) (and x5 x0)) (and (and x1 x1) (not x2))))) (and (or (not (not (and x1 x0))) (or (not (and x2 x5)) (or (and x4 x2) (and x2 x2)))) (not (not (and (and x4 x2) (not x5)))))) (and (not (not (and (or (not x1) (and x4 x2)) (and (not x1) (and x0 x4))))) (and (not (not (and (or x2 x4) (not x1)))) (or (or (or (or x4 x0) (or x4 x5)) (and (and x0 x2) (or x2 x2))) (not (not (or x4 x2))))))) (and (or (not (and (and (not (or x2 x3)) (and (or x4 x5) (not x2))) (not (not (or x2 x1))))) (or (or (and (or (or x3 x3) (not x4)) (and (not x3) (not x4))) (and (or (and x1 x4) (and x3 x5)) (or (or x4 x3) (or x4 x2)))) (not (not (or (or x0 x1) (and x1 x3)))))) (or (or (not (or (or (not x5) (not x5)) (or (and x1 x3) (and x1 x4)))) (not (not (not (not x2))))) (not (or (and (or (and x0 x2) (not x1)) (not (not x3))) (not (or (or x1 x2) (or x5 x0)))))))))) +(check-sat) +(push 1) +(assert (and (and (or (or (not (and (and (and (or (and x0 x1) (not x0)) (and (and x0 x4) (and x3 x3))) (not (and (not x5) (not x2)))) (not (and (not (not x0)) (not (not x4)))))) (not (or (not (and (not (and x4 x1)) (and (or x2 x3) (or x4 x1)))) (and (and (and (or x4 x3) (or x0 x1)) (not (or x0 x5))) (or (or (and x2 x2) (not x0)) (and (or x2 x3) (or x5 x5))))))) (or (or (and (or (and (not (and x5 x1)) (not (or x1 x3))) (not (not (or x2 x3)))) (and (or (not (or x3 x3)) (not (and x0 x2))) (and (not (not x2)) (or (or x2 x2) (and x1 x1))))) (not (or (and (and (and x4 x2) (not x0)) (not (or x4 x5))) (and (not (not x1)) (or (not x4) (not x0)))))) (and (not (or (or (and (not x1) (or x2 x3)) (and (and x2 x5) (or x2 x4))) (or (not (or x2 x5)) (not (not x5))))) (or (or (or (not (and x0 x4)) (and (and x2 x3) (or x3 x4))) (or (and (not x2) (or x5 x0)) (or (and x4 x3) (and x5 x0)))) (or (not (not (and x3 x5))) (or (and (or x2 x0) (and x4 x4)) (or (not x2) (and x3 x1)))))))) (or (not (and (and (or (or (or (or x2 x0) (or x0 x5)) (or (not x2) (and x0 x5))) (and (and (not x4) (not x3)) (and (or x3 x2) (or x5 x1)))) (not (and (or (not x5) (and x3 x2)) (and (and x0 x1) (not x2))))) (and (or (not (and (not x3) (and x0 x1))) (not (not (and x5 x3)))) (and (not (not (not x2))) (not (not (and x4 x0))))))) (and (or (not (and (not (and (or x4 x2) (or x5 x3))) (and (or (or x2 x3) (and x4 x1)) (and (and x1 x1) (or x1 x4))))) (not (or (or (or (not x1) (and x4 x3)) (or (and x5 x3) (not x2))) (or (not (or x1 x5)) (and (not x4) (or x4 x5)))))) (and (or (or (and (not (or x4 x2)) (and (or x3 x2) (not x4))) (not (and (and x3 x1) (or x1 x0)))) (and (or (and (or x0 x2) (or x3 x5)) (not (or x2 x0))) (or (not (not x3)) (and (and x4 x1) (or x1 x4))))) (not (not (not (and (or x1 x5) (and x2 x3))))))))) (and (or (or (not (or (not (and (not (not x3)) (not (not x5)))) (not (and (or (and x3 x4) (or x5 x3)) (not (and x2 x5)))))) (or (or (or (not (or (not x0) (not x4))) (and (and (and x3 x4) (and x0 x4)) (or (or x5 x4) (not x0)))) (or (not (not (and x2 x4))) (not (and (not x2) (or x3 x3))))) (or (and (not (not (not x2))) (or (and (and x1 x4) (not x2)) (not (not x4)))) (not (or (and (and x3 x4) (or x5 x0)) (or (not x2) (or x2 x5))))))) (or (or (or (or (or (not (and x1 x0)) (not (or x0 x3))) (or (or (and x2 x1) (and x1 x5)) (not (or x4 x0)))) (or (and (not (and x1 x5)) (not (not x3))) (or (or (not x1) (not x3)) (not (and x1 x5))))) (and (or (and (and (and x2 x3) (and x4 x0)) (and (not x0) (not x4))) (and (and (not x5) (and x5 x5)) (and (or x4 x5) (and x4 x0)))) (and (or (not (and x2 x0)) (not (not x1))) (not (not (not x3)))))) (and (not (or (and (not (not x0)) (and (and x3 x4) (or x4 x0))) (not (and (not x3) (not x0))))) (not (or (not (or (or x3 x5) (not x2))) (and (or (or x1 x4) (and x1 x1)) (not (or x0 x1)))))))) (and (and (or (or (and (and (not (not x3)) (not (not x1))) (or (and (not x0) (or x5 x2)) (not (or x3 x4)))) (not (not (or (and x2 x4) (not x3))))) (and (or (and (and (and x3 x0) (and x1 x0)) (not (not x3))) (or (not (and x1 x5)) (and (or x0 x5) (not x5)))) (not (or (or (and x5 x2) (or x0 x0)) (not (not x3)))))) (not (or (and (and (or (and x2 x2) (and x1 x3)) (not (or x5 x3))) (or (and (or x3 x0) (or x5 x2)) (or (and x2 x1) (or x5 x3)))) (or (not (or (not x1) (not x4))) (or (and (not x5) (and x0 x3)) (and (or x2 x2) (and x5 x0))))))) (or (not (or (or (and (or (or x4 x1) (or x5 x1)) (not (and x2 x4))) (not (and (or x0 x3) (and x4 x4)))) (or (and (or (or x1 x4) (not x5)) (or (or x2 x2) (or x3 x4))) (not (not (or x3 x4)))))) (or (or (or (or (and (or x0 x5) (not x4)) (or (or x4 x2) (and x3 x4))) (or (not (not x3)) (not (or x4 x0)))) (and (and (not (or x4 x4)) (or (not x4) (or x0 x2))) (not (or (and x1 x5) (not x5))))) (not (and (or (or (and x2 x3) (not x5)) (or (and x3 x2) (or x3 x3))) (or (and (and x5 x3) (and x4 x5)) (and (and x0 x0) (and x3 x3))))))))))) +(assert (and (and (or (and (not (or (and (or (not x4) (not x3)) (and (or x0 x0) (and x4 x3))) (and (not (not x2)) (and (and x2 x4) (and x0 x1))))) (and (not (and (and (or x0 x5) (not x0)) (not (and x1 x5)))) (or (not (and (and x1 x2) (not x5))) (not (not (not x3)))))) (and (not (and (and (or (and x5 x2) (not x0)) (not (or x3 x2))) (and (or (and x0 x1) (and x3 x5)) (or (not x1) (not x1))))) (and (or (and (and (and x0 x4) (not x0)) (not (and x0 x2))) (or (and (not x4) (or x0 x2)) (and (and x1 x3) (not x0)))) (and (and (not (and x3 x0)) (and (and x2 x4) (or x0 x3))) (and (or (or x5 x5) (and x0 x4)) (not (or x3 x5))))))) (not (not (or (or (and (and (and x0 x3) (or x3 x1)) (and (not x4) (not x2))) (not (and (and x0 x5) (and x3 x4)))) (and (or (or (not x3) (and x5 x3)) (not (or x5 x4))) (and (not (not x2)) (not (not x4)))))))) (not (or (and (not (or (or (and (and x3 x2) (not x1)) (and (not x5) (or x0 x4))) (and (and (or x2 x0) (not x1)) (not (or x4 x5))))) (not (or (and (or (not x0) (or x0 x4)) (not (or x4 x5))) (not (not (not x2)))))) (and (or (and (not (and (not x5) (and x5 x0))) (or (not (not x3)) (and (not x4) (and x2 x3)))) (not (or (not (not x1)) (and (not x4) (or x4 x0))))) (and (not (not (and (or x2 x0) (and x1 x5)))) (not (and (and (not x3) (not x2)) (and (not x5) (and x2 x4)))))))))) +(assert (not (or x0 x1))) +(assert (or (not (and (or (or (or (or x2 x2) (or x3 x3)) (or (or x0 x2) (not x2))) (and (not (or x4 x2)) (not (not x2)))) (or (not (or (and x4 x1) (or x5 x4))) (and (not (not x1)) (and (and x2 x5) (and x2 x5)))))) (or (or (and (not (not (not x0))) (and (not (not x1)) (or (or x2 x1) (and x1 x1)))) (and (or (or (and x1 x5) (or x5 x1)) (not (and x1 x2))) (not (not (and x1 x3))))) (or (not (not (not (not x4)))) (or (not (and (and x4 x0) (and x0 x4))) (and (not (not x1)) (not (not x0)))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (and (or (or (not (and (not (and (or x2 x2) (not x0))) (and (and (or x5 x4) (not x3)) (and (or x3 x3) (or x5 x3))))) (not (and (not (and (or x2 x2) (or x2 x4))) (or (or (not x0) (or x1 x0)) (and (or x2 x5) (not x5)))))) (not (or (and (not (and (and x2 x3) (not x4))) (not (or (not x2) (or x0 x4)))) (not (and (not (not x4)) (or (and x2 x5) (and x2 x4))))))) (or (not (not (not (or (not (or x2 x5)) (or (and x3 x1) (or x2 x3)))))) (and (and (not (and (not (not x3)) (and (or x2 x1) (not x1)))) (and (not (not (or x4 x4))) (and (or (or x0 x5) (or x3 x1)) (not (or x3 x3))))) (not (not (or (or (and x0 x4) (or x3 x1)) (not (or x0 x4)))))))) (not (not (not (or (not (or (not (not x4)) (not (or x1 x3)))) (and (not (not (not x5))) (and (not (or x1 x3)) (not (and x4 x4)))))))))) +(check-sat) +(pop 1) +(assert (and (and (not (not (or (or x1 x0) (not x4)))) (not (and (and (or x2 x0) (not x5)) (or (not x5) (and x3 x2))))) (or (and (or (not (not x2)) (not (and x1 x3))) (and (not (or x2 x3)) (or (and x3 x0) (and x4 x2)))) (not (or (not (not x3)) (not (or x0 x5))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (and (not x2) (not x5)) (or (not x0) (and x4 x3))) (and (or (and x1 x2) (not x0)) (or (not x3) (and x3 x0))))) +(assert (and (not (not x5)) (and (or x2 x0) (or x2 x1)))) +(assert (or (and (and (and (and (or (and (not (or x4 x2)) (or (not x0) (and x3 x5))) (and (not (and x1 x2)) (or (not x3) (and x2 x3)))) (or (not (or (or x1 x1) (or x0 x5))) (not (or (or x3 x5) (or x1 x3))))) (not (and (not (not (and x4 x0))) (not (and (or x5 x3) (or x0 x5)))))) (or (or (not (not (or (or x3 x0) (not x0)))) (or (and (or (and x2 x4) (not x4)) (and (and x0 x3) (not x0))) (not (or (or x4 x1) (or x3 x4))))) (and (or (and (and (not x4) (not x2)) (not (not x3))) (not (not (or x2 x1)))) (or (or (or (and x4 x5) (and x4 x4)) (and (not x5) (and x3 x1))) (not (and (or x2 x3) (not x1))))))) (not (or (not (and (or (not (not x5)) (or (not x0) (and x0 x4))) (and (not (and x5 x3)) (or (not x5) (and x4 x0))))) (or (not (not (and (not x1) (or x2 x1)))) (not (or (or (or x5 x0) (not x0)) (not (and x2 x4)))))))) (and (or (or (or (not (or (not (and x2 x3)) (and (and x3 x5) (and x5 x0)))) (and (or (and (and x4 x4) (and x2 x1)) (not (not x3))) (not (and (not x3) (not x0))))) (not (not (not (and (not x3) (or x1 x0)))))) (not (or (or (and (and (not x0) (or x0 x4)) (and (or x3 x4) (or x5 x4))) (and (not (and x1 x5)) (not (and x4 x0)))) (and (not (and (not x4) (and x2 x5))) (or (and (and x1 x4) (not x3)) (or (or x1 x5) (or x0 x3))))))) (or (or (not (not (not (not (and x4 x1))))) (not (and (or (or (or x5 x0) (not x3)) (not (not x4))) (and (and (not x1) (and x1 x4)) (or (not x5) (and x2 x2)))))) (or (not (not (and (or (or x2 x2) (or x0 x2)) (and (or x0 x5) (or x5 x1))))) (not (or (and (and (or x2 x3) (or x5 x0)) (and (and x0 x5) (and x3 x0))) (not (and (or x4 x3) (or x1 x1)))))))))) +(assert (or (or x4 x1) (not x5))) +(check-sat) +(pop 1) +(assert (or (or (or (or (and (not x5) (or x4 x2)) (not (or x4 x3))) (not (and (and x1 x2) (and x0 x0)))) (and (not (not (not x2))) (or (and (not x0) (not x3)) (and (or x4 x4) (not x3))))) (or (and (or (and (or x3 x0) (not x5)) (not (not x0))) (not (or (not x5) (or x2 x5)))) (or (and (and (not x0) (not x3)) (or (and x5 x0) (not x5))) (not (not (or x3 x0))))))) +(assert (or (and (or (or x0 x3) (or x3 x4)) (not (or x5 x3))) (or (and (or x2 x3) (not x4)) (not (not x1))))) +(assert (and (or (or (not (not (or (not (and (or (or x2 x0) (and x3 x4)) (and (not x4) (not x5)))) (or (or (not (or x5 x4)) (or (not x5) (or x5 x2))) (and (not (and x2 x2)) (or (or x5 x1) (or x3 x2))))))) (not (or (and (and (not (and (and x5 x2) (or x0 x0))) (not (and (not x3) (not x2)))) (not (and (not (or x4 x4)) (and (not x1) (or x3 x3))))) (or (or (or (not (not x5)) (and (and x2 x0) (not x2))) (or (not (and x4 x3)) (or (or x2 x2) (and x0 x0)))) (not (not (or (not x0) (not x0)))))))) (and (or (or (or (or (or (not (and x2 x5)) (and (or x4 x5) (and x2 x2))) (or (or (or x2 x1) (and x0 x5)) (and (not x2) (not x1)))) (not (or (not (or x1 x3)) (or (or x5 x5) (or x1 x0))))) (and (and (not (or (not x5) (not x2))) (not (or (or x5 x0) (not x2)))) (not (and (and (not x1) (and x5 x2)) (and (not x0) (and x0 x4)))))) (and (or (not (not (or (and x4 x2) (and x4 x1)))) (not (not (not (or x1 x1))))) (or (and (or (or (not x2) (not x3)) (or (or x1 x2) (or x5 x1))) (or (or (or x4 x2) (or x4 x3)) (and (and x5 x1) (and x0 x1)))) (or (and (not (and x2 x4)) (or (and x5 x2) (and x1 x2))) (not (and (or x4 x1) (or x0 x1))))))) (and (and (and (or (or (not (not x1)) (not (or x0 x4))) (not (and (or x5 x5) (or x4 x1)))) (not (or (or (not x2) (and x1 x1)) (and (and x1 x0) (or x5 x4))))) (and (not (or (or (or x4 x3) (not x4)) (not (or x3 x2)))) (and (or (and (and x3 x2) (and x3 x0)) (not (or x5 x3))) (and (or (and x1 x1) (or x1 x3)) (and (not x5) (not x1)))))) (or (not (not (not (not (or x5 x0))))) (or (or (or (and (and x0 x4) (not x3)) (and (or x1 x0) (not x0))) (and (and (and x0 x0) (or x0 x2)) (not (or x4 x5)))) (not (or (and (or x0 x2) (and x1 x4)) (and (or x3 x5) (not x4))))))))) (or (or (and (and (or (or (not (or (and x1 x1) (and x1 x2))) (or (or (and x3 x2) (not x1)) (and (or x1 x3) (not x4)))) (and (and (and (or x2 x3) (not x1)) (or (not x1) (and x1 x0))) (not (not (and x4 x0))))) (and (or (and (and (or x3 x0) (and x2 x1)) (or (and x3 x5) (or x0 x5))) (or (or (or x3 x1) (or x2 x2)) (or (and x5 x2) (or x3 x1)))) (and (and (and (not x5) (not x0)) (and (or x0 x0) (or x3 x4))) (not (or (and x0 x3) (not x5)))))) (and (and (not (not (or (not x2) (and x2 x1)))) (or (and (not (not x4)) (and (not x3) (not x0))) (and (and (or x5 x1) (or x4 x5)) (not (and x5 x3))))) (or (and (or (and (and x3 x0) (and x5 x0)) (not (not x0))) (and (not (not x2)) (and (or x1 x3) (and x5 x4)))) (not (or (not (and x0 x1)) (or (or x0 x1) (or x4 x5))))))) (or (or (not (and (not (and (and x5 x4) (not x5))) (or (not (or x4 x1)) (not (and x4 x1))))) (or (or (and (and (or x5 x4) (or x2 x0)) (or (or x0 x5) (not x0))) (and (and (not x3) (and x2 x4)) (and (or x2 x0) (or x1 x4)))) (and (and (not (or x0 x3)) (or (and x3 x0) (not x4))) (and (or (and x0 x5) (or x3 x4)) (and (and x5 x3) (or x2 x3)))))) (and (not (not (or (not (and x5 x2)) (not (and x0 x4))))) (not (and (and (and (not x5) (not x4)) (and (or x5 x1) (not x1))) (or (not (or x0 x4)) (not (not x3)))))))) (not (not (and (or (or (or (and (or x3 x4) (not x4)) (not (or x1 x0))) (and (or (or x1 x1) (and x2 x5)) (or (or x5 x2) (not x5)))) (not (not (not (not x5))))) (or (or (and (or (or x5 x1) (not x3)) (and (and x3 x3) (not x1))) (and (and (not x4) (or x4 x2)) (or (or x4 x5) (and x4 x5)))) (or (and (not (and x2 x1)) (or (or x2 x5) (or x1 x4))) (or (and (or x5 x0) (not x5)) (not (or x3 x2))))))))))) +(check-sat) +(push 1) +(assert (or (not (or (or (or (or (or (not (or (not x2) (or x5 x5))) (or (or (and x4 x2) (not x4)) (or (not x1) (or x3 x2)))) (or (and (or (or x2 x3) (and x5 x0)) (and (or x0 x2) (not x2))) (or (not (not x2)) (or (and x0 x3) (or x2 x3))))) (or (and (not (and (or x3 x2) (and x3 x2))) (not (and (and x0 x1) (not x1)))) (or (not (and (and x5 x1) (or x0 x5))) (not (and (and x1 x5) (and x1 x1)))))) (or (and (and (or (or (not x5) (not x2)) (and (and x3 x4) (not x4))) (or (and (not x0) (or x3 x1)) (not (or x3 x0)))) (not (not (or (or x2 x3) (not x0))))) (and (not (and (or (or x0 x5) (and x3 x3)) (and (and x5 x5) (and x3 x5)))) (not (not (or (not x5) (and x2 x0))))))) (and (or (not (not (not (or (and x0 x4) (not x4))))) (not (not (not (not (or x3 x4)))))) (or (or (and (not (or (or x2 x1) (and x0 x2))) (and (or (and x1 x2) (and x5 x2)) (or (or x5 x5) (and x1 x5)))) (or (not (and (and x3 x5) (and x1 x1))) (not (or (not x3) (and x2 x4))))) (not (not (or (and (not x5) (or x2 x2)) (or (and x5 x4) (and x3 x5))))))))) (or (not (or (and (and (or (and (and (or x1 x3) (not x0)) (or (or x2 x5) (or x3 x1))) (or (not (or x3 x5)) (or (not x2) (and x3 x5)))) (not (or (and (or x5 x1) (and x4 x1)) (or (not x3) (or x2 x1))))) (or (not (not (not (or x2 x1)))) (and (not (and (and x0 x4) (or x1 x4))) (not (not (not x0)))))) (not (and (not (and (or (and x3 x5) (not x3)) (or (or x2 x0) (or x0 x0)))) (and (not (and (or x2 x4) (or x2 x3))) (and (or (not x1) (and x4 x3)) (or (or x0 x5) (or x3 x5)))))))) (and (and (or (and (not (or (not (not x5)) (not (and x2 x2)))) (not (or (and (or x4 x1) (or x3 x2)) (or (and x4 x3) (or x1 x1))))) (or (or (or (not (and x0 x4)) (and (not x5) (and x2 x3))) (and (and (and x4 x3) (not x1)) (not (not x2)))) (or (not (not (not x3))) (not (or (not x2) (not x3)))))) (or (or (or (and (or (or x4 x1) (not x0)) (or (and x2 x0) (not x4))) (not (not (or x5 x3)))) (and (and (not (not x0)) (and (and x1 x4) (and x4 x5))) (not (or (not x0) (or x5 x2))))) (or (or (and (or (or x1 x4) (or x4 x2)) (or (and x0 x1) (not x3))) (or (or (and x1 x1) (and x3 x0)) (and (or x4 x1) (and x1 x1)))) (not (and (and (not x0) (not x0)) (or (and x1 x0) (or x5 x0))))))) (or (or (and (or (and (or (not x0) (or x0 x1)) (and (not x2) (and x3 x2))) (or (or (or x0 x3) (not x0)) (or (and x5 x5) (not x5)))) (or (not (not (and x3 x1))) (and (or (not x2) (or x3 x4)) (and (and x5 x1) (or x3 x4))))) (or (or (and (or (and x0 x4) (and x5 x4)) (or (not x0) (or x1 x1))) (and (not (and x1 x5)) (or (or x3 x4) (and x1 x3)))) (not (and (or (not x5) (not x2)) (and (not x5) (not x2)))))) (or (or (and (not (and (not x3) (or x2 x2))) (and (not (not x1)) (and (and x0 x2) (and x5 x4)))) (and (not (and (and x0 x5) (and x5 x3))) (and (or (and x3 x0) (or x1 x4)) (or (or x4 x5) (and x4 x5))))) (not (not (or (not (and x3 x4)) (or (or x5 x2) (or x2 x0))))))))))) +(assert (and (not (and (not (not (not (or (and x5 x1) (or x2 x2))))) (not (not (not (and (or x2 x4) (and x0 x1))))))) (not (or (or (and (or (and (and x3 x3) (and x5 x0)) (not (and x0 x3))) (and (not (not x5)) (or (and x2 x2) (and x3 x3)))) (not (not (or (and x2 x5) (and x3 x3))))) (or (not (and (or (and x4 x3) (or x3 x1)) (and (or x1 x0) (or x1 x3)))) (not (and (and (or x4 x1) (not x0)) (not (not x5))))))))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(assert (or (and (not (or (and (and (not (not (and x1 x2))) (and (not (not x1)) (not (and x3 x0)))) (not (or (and (and x0 x2) (or x3 x3)) (not (not x1))))) (not (or (and (not (not x1)) (not (not x0))) (not (or (or x0 x3) (not x0))))))) (or (and (and (not (or (or (and x2 x2) (or x1 x2)) (not (and x3 x3)))) (not (or (not (not x2)) (and (and x2 x1) (and x1 x1))))) (or (or (and (not (or x2 x3)) (or (not x0) (and x1 x1))) (or (or (or x3 x2) (and x2 x3)) (or (and x1 x0) (not x3)))) (or (and (not (or x3 x3)) (or (and x2 x2) (or x3 x0))) (and (not (or x0 x2)) (and (not x1) (or x2 x3)))))) (not (not (not (or (not (not x3)) (or (and x0 x3) (or x0 x3)))))))) (not (or (or (or (not (or (or (and x3 x0) (not x3)) (or (and x2 x0) (and x1 x2)))) (and (or (not (and x0 x2)) (not (or x1 x1))) (or (or (or x3 x1) (or x1 x2)) (or (not x1) (and x1 x1))))) (not (not (not (and (and x0 x3) (or x1 x1)))))) (and (and (and (and (and (or x3 x0) (or x1 x3)) (and (not x1) (not x2))) (not (not (not x0)))) (not (and (or (and x3 x3) (or x2 x3)) (not (or x1 x1))))) (and (or (not (and (and x0 x2) (not x0))) (or (not (or x3 x0)) (not (or x1 x0)))) (or (and (and (and x2 x0) (not x1)) (not (not x0))) (and (or (not x3) (or x1 x1)) (not (and x0 x3)))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (and x0 x2)) (and (not x2) (and x0 x2)))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (and (or (not (or (or (and (not (or x3 x3)) (or (not x1) (or x0 x2))) (and (or (and x3 x1) (or x3 x3)) (not (or x1 x3)))) (or (or (not (and x3 x2)) (not (or x1 x1))) (or (and (or x0 x1) (and x0 x1)) (and (or x0 x2) (and x1 x1)))))) (not (and (not (not (not (and x0 x1)))) (or (and (or (or x1 x3) (not x3)) (and (and x3 x1) (and x1 x1))) (not (not (not x1))))))) (not (and (or (and (or (not (and x0 x3)) (and (or x0 x0) (or x0 x0))) (and (and (or x1 x0) (and x1 x2)) (and (not x3) (or x0 x1)))) (and (not (or (not x0) (not x2))) (or (or (and x0 x0) (not x0)) (and (not x1) (and x2 x3))))) (and (and (not (or (and x3 x1) (or x0 x1))) (not (or (or x2 x2) (not x2)))) (not (or (and (and x2 x3) (or x2 x0)) (or (and x0 x0) (not x2)))))))) (not (or (or (or (and (and (or (and x2 x0) (not x3)) (or (or x0 x1) (not x2))) (not (and (not x3) (not x2)))) (not (and (and (and x0 x0) (not x3)) (and (not x3) (and x0 x2))))) (not (not (and (and (and x2 x1) (not x3)) (or (or x3 x2) (not x2)))))) (not (or (not (or (not (and x0 x0)) (or (not x3) (or x3 x3)))) (or (and (or (and x0 x3) (not x2)) (not (not x2))) (or (not (or x0 x3)) (or (and x1 x2) (and x1 x0)))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (and (not (or (and (or (or x0 x3) (or x2 x1)) (and (or x1 x0) (not x0))) (or (and (not x2) (and x2 x3)) (not (and x2 x1))))) (and (not (and (or (and x3 x1) (not x2)) (not (or x3 x3)))) (or (not (and (and x1 x2) (and x0 x0))) (or (or (or x3 x2) (not x1)) (or (and x3 x2) (not x0)))))))) +(check-sat) +(push 1) +(assert (and (and x3 x1) (and x2 x2))) +(check-sat) +(pop 1) +(assert (or (or (and (not (or (and (not (and (not (not x1)) (or (and x0 x2) (and x0 x3)))) (not (not (and (not x1) (and x0 x3))))) (not (not (not (and (not x0) (not x2))))))) (not (or (not (and (not (or (or x1 x1) (not x1))) (not (or (not x3) (or x3 x0))))) (not (or (not (or (or x2 x0) (not x3))) (and (not (and x0 x2)) (not (and x2 x3)))))))) (and (or (not (or (not (not (or (or x3 x2) (and x2 x3)))) (and (or (or (not x3) (or x0 x2)) (not (and x1 x2))) (or (and (or x3 x2) (not x0)) (and (and x3 x3) (not x2)))))) (not (not (not (or (and (or x1 x3) (or x2 x2)) (or (not x0) (not x1))))))) (and (or (not (or (and (or (and x1 x3) (or x2 x2)) (or (not x1) (not x3))) (or (or (and x2 x0) (not x3)) (not (not x1))))) (or (or (not (not (not x0))) (not (or (not x0) (not x1)))) (or (and (and (or x2 x1) (and x2 x0)) (not (and x0 x2))) (not (and (not x0) (or x3 x1)))))) (and (not (and (and (or (and x3 x0) (and x0 x1)) (not (or x1 x1))) (not (and (not x3) (not x0))))) (not (and (or (not (not x1)) (and (not x0) (or x1 x0))) (not (not (and x1 x1))))))))) (and (not (not (not (and (or (and (and (or x2 x3) (not x0)) (or (and x3 x3) (and x2 x0))) (or (not (or x2 x1)) (not (or x3 x1)))) (and (and (and (and x3 x2) (or x3 x2)) (not (not x0))) (or (and (or x2 x1) (and x1 x0)) (and (not x2) (not x1)))))))) (and (or (and (or (not (not (not (or x2 x0)))) (not (or (and (and x2 x2) (and x2 x1)) (and (and x3 x0) (or x1 x0))))) (not (or (or (and (not x2) (and x2 x1)) (not (not x0))) (not (and (and x3 x0) (or x1 x3)))))) (not (or (not (or (and (and x2 x2) (not x3)) (or (not x2) (or x0 x2)))) (or (or (and (or x0 x1) (or x0 x1)) (not (not x2))) (or (or (and x2 x0) (and x1 x2)) (and (not x1) (or x3 x3))))))) (or (and (or (and (and (or (and x3 x3) (and x0 x0)) (or (or x0 x3) (or x0 x3))) (and (not (or x3 x3)) (and (not x3) (or x1 x2)))) (and (and (and (not x0) (or x1 x3)) (or (not x2) (or x1 x2))) (and (or (not x3) (or x0 x0)) (or (not x0) (not x2))))) (and (not (and (or (not x3) (not x0)) (or (not x2) (or x0 x3)))) (not (not (not (and x0 x0)))))) (or (and (and (and (or (not x1) (not x0)) (and (or x2 x0) (not x2))) (or (not (and x1 x2)) (and (or x2 x2) (not x2)))) (and (not (not (not x3))) (or (and (not x0) (and x2 x1)) (and (not x3) (not x1))))) (or (and (or (not (or x1 x2)) (or (and x2 x1) (not x0))) (and (or (and x3 x0) (or x2 x3)) (or (or x0 x3) (and x3 x2)))) (or (not (not (and x2 x2))) (or (not (not x2)) (or (or x0 x3) (or x0 x2))))))))))) +(check-sat) +(push 1) +(assert (or (or (not x3) (and x3 x0)) (not (and x3 x1)))) +(assert (not x0)) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (or (or (and (and (not (or (not x1) (and x1 x1))) (and (and (or x3 x3) (not x2)) (and (not x0) (or x2 x1)))) (not (or (or (and x0 x2) (not x2)) (not (and x0 x1))))) (not (and (or (and (and x0 x1) (not x0)) (or (and x0 x2) (or x1 x3))) (and (or (or x3 x1) (and x3 x1)) (or (or x3 x1) (not x0)))))) (and (and (not (not (not (or x1 x2)))) (or (or (or (not x1) (and x0 x3)) (and (not x2) (not x0))) (or (or (not x1) (not x1)) (and (and x2 x1) (not x2))))) (not (not (and (not (or x2 x2)) (and (not x2) (and x1 x2)))))))) (not (or (and (and (not (not (and (and x3 x2) (and x0 x3)))) (not (not (not (not x1))))) (and (not (not (and (not x2) (not x1)))) (not (or (or (or x2 x3) (not x1)) (and (and x0 x1) (or x3 x0)))))) (and (not (and (and (and (not x3) (not x0)) (and (not x0) (or x3 x2))) (not (and (and x0 x2) (and x3 x0))))) (not (and (and (not (and x1 x1)) (or (and x1 x1) (or x0 x1))) (not (or (or x0 x0) (and x2 x3)))))))))) +(check-sat) +(pop 1) +(assert (not (and (and (and (or (or (or (and x0 x2) (and x1 x3)) (or (not x0) (and x2 x1))) (and (or (and x0 x2) (not x2)) (or (not x3) (and x1 x0)))) (or (not (or (and x1 x1) (or x1 x3))) (and (and (and x0 x0) (and x2 x2)) (and (not x0) (or x2 x3))))) (not (not (and (not (or x0 x2)) (or (and x1 x2) (or x2 x3)))))) (or (and (or (not (or (not x3) (or x1 x1))) (and (not (or x2 x2)) (or (or x3 x3) (and x3 x3)))) (not (or (or (and x2 x2) (and x1 x2)) (not (not x1))))) (not (not (not (and (or x0 x3) (or x3 x2))))))))) +(assert (or (not (and (not x1) (not x3))) (or (not (and x2 x0)) (and (or x1 x0) (or x2 x1))))) +(assert (and (not (or (and x2 x0) (not x0))) (or (not (and x1 x1)) (and (and x1 x3) (and x3 x3))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(check-sat) +(push 1) +(assert (or (or (or (and (and (not (and (or x0 x0) (not x0))) (not (or (or x2 x2) (not x0)))) (or (or (not (or x0 x0)) (or (and x0 x2) (or x0 x2))) (and (and (and x1 x1) (and x2 x1)) (not (not x2))))) (and (not (not (and (not x2) (and x0 x2)))) (not (not (and (not x2) (not x1)))))) (not (or (and (not (and (not x2) (not x0))) (and (not (not x0)) (and (not x1) (and x2 x2)))) (and (not (and (not x2) (or x1 x0))) (or (or (or x1 x0) (or x0 x0)) (or (or x0 x0) (not x1))))))) (not (not (not (and (not (or (or x2 x0) (not x2))) (not (and (not x0) (or x0 x1))))))))) +(assert (or (not (or (and (or (or x0 x0) (or x2 x2)) (and (not x1) (or x2 x2))) (and (not (not x1)) (and (or x0 x0) (or x0 x1))))) (not (and (or (and (and x1 x2) (not x1)) (not (not x2))) (not (and (and x2 x0) (not x1))))))) +(assert (or (not (not x2)) (not (not x0)))) +(assert (not (or (not (or (and (and (and x0 x0) (or x1 x1)) (or (or x0 x2) (not x1))) (not (or (or x0 x1) (or x0 x0))))) (not (not (not (or (or x1 x1) (not x2)))))))) +(check-sat) +(pop 1) +(assert (not (and (not (and (and (or (and (and (or (not x0) (not x1)) (and (or x1 x1) (not x2))) (and (and (or x1 x0) (and x1 x2)) (and (not x0) (not x2)))) (not (or (or (or x1 x0) (not x1)) (or (or x0 x1) (not x2))))) (or (or (and (not (not x0)) (or (or x0 x1) (not x0))) (or (not (or x0 x2)) (not (or x0 x0)))) (not (and (or (and x1 x1) (not x0)) (or (and x1 x1) (or x1 x0)))))) (or (and (not (or (not (and x0 x0)) (and (and x0 x2) (and x2 x0)))) (not (and (and (or x0 x2) (and x0 x2)) (and (not x0) (and x0 x1))))) (and (or (not (and (and x2 x1) (not x2))) (or (and (and x2 x2) (and x2 x2)) (or (or x0 x1) (or x1 x2)))) (or (and (and (and x2 x1) (or x1 x0)) (and (or x2 x0) (not x1))) (and (not (or x2 x2)) (or (and x2 x0) (and x0 x0)))))))) (or (and (or (not (and (not (not (or x2 x0))) (and (or (and x0 x1) (or x0 x1)) (not (not x1))))) (not (and (and (or (or x0 x1) (not x1)) (not (not x2))) (not (or (not x2) (not x2)))))) (and (or (and (or (not (and x2 x2)) (or (and x1 x2) (or x2 x2))) (and (or (not x2) (and x2 x2)) (not (not x2)))) (not (not (and (not x2) (not x1))))) (not (and (and (and (or x1 x1) (and x0 x0)) (or (or x0 x0) (not x1))) (or (and (or x2 x1) (not x2)) (and (or x2 x2) (not x1))))))) (not (or (and (and (or (or (not x2) (not x0)) (not (and x1 x0))) (and (not (not x0)) (or (and x1 x0) (or x1 x0)))) (and (and (or (and x0 x2) (not x2)) (and (or x2 x2) (not x1))) (not (or (and x0 x1) (and x1 x0))))) (or (not (or (not (and x1 x0)) (not (not x2)))) (not (not (and (or x2 x0) (not x1))))))))))) +(check-sat) +(push 1) +(assert (or (and (and (or (or (and (not (and (or (or x2 x0) (or x0 x1)) (not (or x2 x1)))) (or (not (not (not x2))) (not (not (or x1 x1))))) (or (or (and (or (and x2 x0) (not x1)) (or (or x2 x2) (and x1 x2))) (or (or (and x0 x0) (and x2 x0)) (or (not x2) (or x0 x1)))) (and (or (and (or x0 x0) (or x2 x0)) (not (not x1))) (not (and (or x1 x2) (or x1 x1)))))) (and (not (not (and (or (or x1 x0) (and x1 x1)) (not (or x1 x0))))) (and (and (and (or (or x0 x2) (and x0 x2)) (and (and x2 x2) (and x0 x1))) (or (or (or x1 x1) (not x2)) (not (not x1)))) (not (not (or (or x1 x0) (and x2 x0))))))) (not (not (and (or (not (or (and x1 x2) (not x2))) (and (and (or x2 x0) (and x1 x0)) (and (or x1 x0) (or x2 x1)))) (not (or (not (not x0)) (not (and x2 x2)))))))) (and (or (and (or (not (not (and (and x1 x1) (and x1 x1)))) (or (and (not (and x0 x1)) (or (or x2 x2) (or x0 x1))) (and (not (not x0)) (not (and x0 x0))))) (not (and (or (and (not x1) (not x2)) (not (or x2 x1))) (and (and (not x0) (and x0 x2)) (or (and x2 x2) (not x2)))))) (or (and (and (not (and (or x1 x0) (or x0 x1))) (not (or (or x2 x1) (or x1 x0)))) (and (and (or (and x1 x1) (not x2)) (or (not x0) (and x0 x1))) (not (not (or x0 x2))))) (not (and (not (or (and x2 x0) (or x2 x0))) (not (not (not x0))))))) (or (or (not (and (and (not (not x0)) (or (and x1 x2) (not x0))) (and (not (not x0)) (and (or x0 x2) (not x1))))) (and (not (and (or (not x1) (and x0 x0)) (and (not x1) (and x2 x2)))) (not (and (or (and x0 x0) (not x0)) (and (not x2) (and x0 x2)))))) (and (and (or (not (or (not x1) (or x1 x2))) (or (or (and x1 x1) (and x0 x0)) (not (and x0 x0)))) (not (or (and (or x0 x0) (not x1)) (or (and x0 x2) (or x1 x1))))) (not (and (not (not (and x2 x1))) (or (and (not x1) (not x0)) (not (or x0 x2))))))))) (or (and (or (and (not (or (or (or (not x1) (or x0 x0)) (and (or x2 x1) (not x1))) (and (or (not x2) (or x1 x2)) (or (and x2 x1) (and x1 x0))))) (and (not (and (and (or x2 x0) (not x2)) (and (or x1 x1) (or x2 x0)))) (not (or (and (and x0 x2) (and x0 x2)) (not (or x1 x1)))))) (not (or (not (or (and (and x0 x1) (not x1)) (or (and x2 x1) (not x2)))) (and (and (and (not x2) (and x2 x1)) (not (or x2 x2))) (and (and (or x1 x1) (not x1)) (or (and x0 x1) (not x1))))))) (not (and (or (and (or (or (not x2) (not x1)) (not (and x1 x1))) (or (not (or x0 x0)) (not (and x2 x1)))) (not (and (not (and x1 x1)) (or (not x1) (and x0 x2))))) (or (or (or (not (or x2 x2)) (and (and x1 x0) (and x1 x1))) (not (and (or x1 x0) (or x0 x2)))) (and (not (or (or x2 x2) (and x2 x0))) (not (and (and x2 x2) (or x1 x1)))))))) (not (or (not (or (not (and (not (and x2 x2)) (and (or x0 x1) (and x2 x0)))) (and (not (not (and x2 x0))) (or (and (and x0 x0) (not x0)) (and (and x0 x1) (not x0)))))) (or (not (or (or (and (and x0 x2) (and x2 x0)) (and (and x2 x1) (or x2 x2))) (and (or (or x0 x0) (or x1 x0)) (and (and x2 x1) (or x0 x1))))) (and (or (or (not (or x0 x1)) (not (or x0 x1))) (or (not (not x0)) (not (and x0 x2)))) (not (not (or (or x2 x2) (not x2))))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (or (and (and (or (or (not (not (not (and x3 x2)))) (and (and (or (and x1 x1) (not x9)) (or (or x9 x5) (not x5))) (or (not (or x6 x3)) (not (not x5))))) (or (not (or (and (and x2 x5) (or x5 x6)) (not (or x0 x5)))) (not (or (or (or x0 x6) (not x1)) (not (not x9)))))) (or (and (not (or (or (not x2) (and x9 x9)) (or (not x6) (and x8 x5)))) (and (or (not (not x8)) (not (not x5))) (and (or (or x7 x1) (and x6 x9)) (or (and x5 x5) (and x0 x8))))) (and (and (or (or (not x9) (and x3 x0)) (and (or x6 x4) (and x0 x2))) (not (not (not x3)))) (or (or (or (or x2 x4) (or x8 x5)) (not (not x5))) (and (not (or x9 x9)) (not (not x1))))))) (and (or (and (and (not (not (or x9 x7))) (not (or (or x1 x5) (and x5 x0)))) (and (and (or (and x4 x3) (or x4 x4)) (and (or x7 x7) (or x6 x3))) (not (or (not x5) (or x8 x5))))) (or (or (not (and (or x1 x1) (and x4 x7))) (or (or (or x0 x3) (or x6 x8)) (and (not x5) (not x9)))) (and (and (and (and x8 x4) (and x5 x7)) (and (not x5) (not x5))) (not (not (not x8)))))) (not (or (and (or (or (not x6) (and x6 x9)) (and (and x0 x3) (or x4 x3))) (not (and (not x8) (and x3 x2)))) (or (and (not (or x6 x9)) (and (or x2 x4) (or x6 x4))) (not (and (or x1 x4) (and x1 x9)))))))) (or (not (and (not (and (or (not (not x0)) (not (or x5 x5))) (or (or (not x9) (or x8 x5)) (and (or x2 x1) (or x4 x4))))) (not (and (or (and (and x5 x6) (or x2 x3)) (or (not x3) (and x1 x0))) (and (and (and x3 x9) (and x1 x7)) (or (not x9) (and x7 x5))))))) (or (not (or (or (not (not (and x5 x0))) (or (and (not x3) (not x8)) (or (and x5 x7) (not x8)))) (or (and (and (or x3 x9) (or x5 x6)) (or (or x0 x7) (and x7 x6))) (or (or (or x3 x3) (not x7)) (not (or x4 x4)))))) (not (not (and (not (or (or x8 x5) (not x9))) (not (or (and x3 x3) (or x3 x2)))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (or (or x0 x9) (not x9)) (not (or x8 x3)))) +(check-sat) +(push 1) +(assert (or (not (not (and x5 x8))) (not (not (not x7))))) +(check-sat) +(pop 1) +(assert (not (not (or (or (not x4) (not x5)) (not (not x6)))))) +(assert (not (not (and (and x8 x5) (or x4 x1))))) +(assert (and (not (not (or (or (and (and (or (and x7 x6) (or x2 x3)) (or (or x3 x4) (not x6))) (or (not (or x9 x1)) (not (and x7 x8)))) (and (not (not (and x2 x0))) (not (and (not x7) (or x3 x3))))) (and (or (and (not (and x2 x0)) (and (or x5 x9) (and x4 x2))) (or (or (not x2) (and x4 x4)) (or (and x4 x7) (not x0)))) (and (or (not (not x8)) (or (or x2 x0) (or x2 x6))) (and (and (not x3) (or x9 x9)) (or (not x2) (and x4 x6)))))))) (not (or (not (not (and (not (or (and x7 x9) (or x0 x0))) (not (not (or x7 x9)))))) (and (not (or (and (not (or x0 x6)) (and (and x7 x3) (and x7 x8))) (or (and (not x7) (or x5 x6)) (and (not x9) (or x4 x2))))) (and (not (or (or (and x2 x2) (not x3)) (or (and x2 x0) (or x5 x4)))) (not (or (or (not x7) (or x0 x5)) (or (or x4 x8) (and x8 x2)))))))))) +(assert (or (not (and x0 x3)) (or (or x0 x1) (or x2 x7)))) +(check-sat) +(pop 1) +(assert (or x4 x9)) +(check-sat) +(push 1) +(assert (or (or (or (not (or x9 x3)) (and (and x1 x9) (not x3))) (not (or (or x6 x1) (or x9 x8)))) (and (and (not (and x0 x6)) (and (not x0) (not x2))) (and (and (or x4 x5) (or x2 x8)) (and (and x5 x1) (and x4 x9)))))) +(check-sat) +(pop 1) +(assert (and (not (or (and (not (not (not (or x9 x5)))) (not (or (not (or x5 x4)) (not (or x8 x9))))) (and (or (not (and (or x0 x0) (not x8))) (not (or (and x7 x5) (or x0 x2)))) (or (not (not (not x2))) (and (and (or x0 x4) (and x2 x2)) (and (and x6 x7) (not x9))))))) (and (and (not (not (or (or (not x8) (and x9 x1)) (and (and x5 x8) (or x9 x3))))) (and (and (not (or (not x7) (and x0 x9))) (and (not (and x3 x4)) (not (or x4 x0)))) (or (or (and (and x0 x0) (or x1 x5)) (and (and x7 x5) (and x6 x0))) (and (and (or x4 x7) (not x6)) (not (and x1 x0)))))) (or (or (and (and (or (and x5 x1) (not x5)) (not (and x2 x4))) (and (and (not x6) (or x1 x6)) (not (and x1 x1)))) (and (and (and (or x1 x6) (or x7 x2)) (not (not x8))) (not (and (and x6 x1) (not x1))))) (not (or (or (and (or x0 x9) (not x6)) (not (not x8))) (and (and (or x7 x2) (or x7 x0)) (not (not x5))))))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(check-sat) +(push 1) +(assert (not (not (or (and (or (or x1 x1) (and x0 x1)) (or (or x2 x0) (or x0 x0))) (not (and (or x2 x0) (not x1))))))) +(assert (and (and x0 x1) (and x1 x0))) +(assert (or (not (or (or (or (and (or (and (and x1 x2) (and x1 x1)) (and (not x1) (and x2 x0))) (or (not (not x2)) (or (and x1 x1) (and x2 x1)))) (or (or (not (or x1 x2)) (and (or x0 x2) (or x2 x1))) (not (or (and x1 x2) (or x2 x0))))) (or (not (or (and (or x2 x0) (or x2 x1)) (and (not x2) (and x2 x1)))) (or (not (and (or x2 x1) (and x2 x2))) (and (and (not x1) (and x0 x2)) (and (and x0 x2) (or x1 x2)))))) (not (and (or (or (or (not x2) (and x0 x1)) (or (or x2 x2) (or x2 x2))) (and (and (not x2) (not x0)) (not (and x1 x0)))) (or (not (not (or x2 x0))) (and (not (or x2 x2)) (not (not x2)))))))) (not (or (and (not (and (and (not (not x2)) (and (not x2) (not x2))) (or (and (not x0) (or x1 x1)) (or (and x1 x0) (and x0 x0))))) (and (or (or (not (and x1 x1)) (not (or x1 x1))) (not (and (and x1 x0) (or x2 x0)))) (not (not (or (not x2) (and x0 x0)))))) (or (or (and (and (not (and x1 x1)) (or (or x0 x0) (or x2 x2))) (not (and (and x1 x0) (not x0)))) (or (not (not (and x1 x2))) (or (or (not x1) (and x1 x2)) (or (or x0 x2) (and x0 x0))))) (and (or (not (and (or x2 x2) (and x2 x2))) (and (not (not x1)) (and (or x1 x2) (and x1 x0)))) (not (or (not (or x1 x0)) (not (or x0 x2)))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (and (not (and x1 x1)) (and (and x0 x0) (not x2))))) +(check-sat) +(push 1) +(assert (or (and (or (and (or (and x0 x0) (not x0)) (and (and x1 x0) (or x0 x1))) (or (or (or x1 x1) (and x2 x2)) (not (and x0 x0)))) (or (and (and (and x2 x0) (not x1)) (or (or x2 x2) (and x0 x0))) (and (or (and x1 x1) (and x2 x1)) (and (not x0) (and x1 x0))))) (not (not (or (or (or x1 x1) (or x1 x0)) (not (or x2 x1))))))) +(assert (not (not (and (and (or (or (and x0 x2) (or x2 x0)) (and (and x1 x1) (or x1 x2))) (and (or (and x1 x0) (not x1)) (or (and x0 x0) (not x2)))) (not (and (not (or x2 x0)) (not (not x0)))))))) +(assert (not (or (and (and x1 x0) (not x2)) (or (or x2 x1) (or x0 x2))))) +(assert (or (not (and (or (and (or (not (or (and x1 x0) (not x2))) (and (not (or x2 x1)) (not (or x0 x2)))) (and (not (and (not x2) (or x0 x2))) (not (or (not x0) (and x0 x2))))) (or (not (and (and (or x1 x2) (not x1)) (or (not x0) (or x0 x1)))) (or (and (and (not x1) (and x2 x1)) (and (and x2 x1) (or x1 x0))) (or (not (or x1 x1)) (or (or x1 x2) (not x1)))))) (not (or (not (not (not (or x1 x0)))) (not (or (and (or x0 x0) (not x2)) (not (or x1 x2)))))))) (or (and (or (not (or (or (or (and x1 x0) (or x0 x0)) (or (or x2 x1) (not x2))) (not (not (and x2 x2))))) (not (not (or (and (or x2 x1) (or x1 x2)) (or (and x2 x1) (or x0 x1)))))) (not (and (not (not (not (and x2 x1)))) (and (and (not (not x1)) (and (not x0) (not x1))) (or (or (or x2 x1) (not x2)) (and (not x1) (not x0))))))) (or (and (or (not (not (not (and x1 x2)))) (or (not (and (or x0 x0) (not x0))) (and (not (not x1)) (not (and x0 x2))))) (and (and (and (and (and x2 x1) (or x2 x2)) (not (or x0 x1))) (not (not (and x1 x2)))) (and (and (not (or x0 x1)) (or (and x2 x2) (not x1))) (and (and (or x2 x2) (not x1)) (and (or x1 x1) (or x2 x0)))))) (or (and (not (and (and (and x0 x1) (not x1)) (or (or x0 x0) (not x0)))) (and (or (not (and x1 x2)) (not (or x0 x2))) (and (or (or x0 x1) (or x2 x0)) (not (or x1 x0))))) (not (and (not (and (and x0 x1) (and x0 x0))) (not (or (not x0) (or x1 x0)))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (and (or (and x0 x2) (not x2)) (and (and x1 x0) (not x0))) (not (and (and x2 x1) (or x0 x1)))))) +(check-sat) +(push 1) +(assert (and (not (and (or (not (and (and (not (not (or x2 x1))) (or (not (or x2 x2)) (and (not x2) (and x0 x1)))) (or (and (not (or x1 x2)) (and (and x2 x1) (or x2 x0))) (not (and (or x1 x2) (not x0)))))) (not (or (or (not (not (not x2))) (not (or (or x1 x1) (and x0 x1)))) (or (and (not (not x0)) (and (or x0 x0) (not x1))) (or (not (and x1 x2)) (and (and x0 x0) (and x1 x0))))))) (and (and (or (or (and (or (and x2 x0) (not x0)) (or (or x2 x1) (and x2 x1))) (or (or (or x2 x1) (not x0)) (or (and x2 x2) (not x2)))) (or (and (or (or x2 x0) (and x0 x1)) (not (and x1 x0))) (or (or (not x0) (not x0)) (or (not x2) (not x0))))) (not (or (and (and (not x1) (and x0 x0)) (not (and x1 x0))) (or (and (and x0 x2) (and x1 x0)) (and (and x0 x0) (not x1)))))) (or (and (or (or (and (and x2 x0) (or x0 x2)) (or (and x2 x2) (not x2))) (or (and (or x0 x1) (and x2 x2)) (or (and x0 x0) (or x2 x1)))) (not (or (and (and x2 x1) (not x2)) (and (not x1) (and x1 x0))))) (or (or (and (not (and x0 x1)) (and (or x0 x1) (not x1))) (not (or (and x2 x0) (and x1 x1)))) (or (or (and (and x2 x0) (or x0 x1)) (and (not x2) (or x2 x1))) (and (or (not x1) (not x1)) (or (and x2 x1) (not x1))))))))) (and (or (not (or (not (or (and (and (or x2 x1) (or x0 x2)) (or (or x0 x2) (and x1 x0))) (not (or (or x0 x1) (and x2 x2))))) (or (or (and (and (and x2 x0) (and x1 x1)) (and (or x0 x0) (and x1 x1))) (and (and (and x1 x1) (not x0)) (and (not x1) (not x0)))) (and (or (and (not x2) (not x1)) (not (or x0 x0))) (not (not (and x1 x0))))))) (or (not (not (not (and (and (and x2 x0) (not x1)) (or (or x1 x0) (and x2 x2)))))) (not (and (and (or (or (not x0) (not x0)) (and (and x1 x1) (and x0 x1))) (and (and (not x2) (and x2 x1)) (not (not x2)))) (and (or (and (or x2 x0) (or x2 x1)) (and (and x2 x1) (and x0 x2))) (not (not (not x0)))))))) (and (or (not (and (and (and (and (or x1 x1) (not x0)) (not (not x1))) (or (not (not x2)) (and (and x1 x1) (not x0)))) (and (or (or (and x2 x2) (or x0 x1)) (and (and x0 x2) (not x1))) (and (not (not x2)) (and (not x2) (not x1)))))) (not (or (or (or (and (and x1 x1) (not x0)) (not (and x2 x0))) (and (and (and x1 x1) (not x0)) (or (and x2 x0) (or x2 x0)))) (not (and (not (not x2)) (or (or x1 x2) (not x0))))))) (and (not (not (or (and (and (and x2 x2) (not x1)) (not (or x2 x1))) (or (not (and x0 x0)) (not (and x2 x1)))))) (or (not (not (not (not (not x0))))) (or (not (and (or (and x2 x0) (and x2 x0)) (or (not x1) (or x1 x2)))) (or (not (not (or x2 x1))) (not (not (not x0))))))))))) +(check-sat) +(push 1) +(assert (or (and (and (and (not (or (or (or (not x1) (and x2 x0)) (or (not x1) (or x0 x1))) (not (or (not x1) (or x1 x0))))) (and (or (or (and (not x2) (not x1)) (or (or x2 x2) (or x1 x0))) (not (and (and x0 x1) (or x0 x2)))) (not (or (or (and x1 x0) (or x0 x2)) (and (and x1 x1) (or x0 x0)))))) (not (and (not (not (or (or x0 x2) (not x2)))) (or (not (not (and x2 x2))) (not (not (and x1 x1))))))) (not (not (or (and (not (not (not x0))) (and (or (not x2) (not x2)) (not (and x0 x0)))) (or (or (and (not x2) (not x2)) (or (not x2) (and x2 x1))) (and (and (not x0) (or x2 x2)) (and (or x1 x1) (not x0)))))))) (not (or (and (or (or (or (and (and x0 x1) (or x0 x1)) (and (or x0 x0) (not x2))) (not (and (not x0) (or x2 x2)))) (and (or (and (not x1) (or x2 x0)) (not (not x0))) (or (or (and x1 x1) (not x0)) (not (or x0 x0))))) (not (not (or (or (not x1) (not x2)) (and (or x2 x2) (not x1)))))) (and (and (not (or (and (or x0 x2) (not x2)) (not (and x2 x2)))) (and (and (or (or x1 x1) (not x1)) (not (and x0 x0))) (not (not (not x2))))) (and (and (and (and (and x1 x1) (not x0)) (not (not x2))) (and (not (not x0)) (or (or x1 x0) (and x1 x1)))) (or (or (and (and x0 x1) (or x0 x0)) (or (not x1) (and x0 x1))) (not (and (and x1 x1) (not x1)))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and x2 x2)) +(check-sat) +(push 1) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(assert (or (not (not (and (and (not (not (not (not (or x2 x4))))) (and (not (or (not (not x4)) (or (or x2 x8) (or x3 x7)))) (and (or (or (not x8) (not x8)) (not (not x5))) (or (not (not x3)) (or (or x3 x7) (or x5 x2)))))) (or (and (and (or (and (and x8 x5) (not x5)) (and (or x8 x6) (not x7))) (and (and (or x7 x2) (or x6 x5)) (and (or x8 x6) (and x4 x0)))) (not (or (and (not x3) (and x6 x6)) (or (not x8) (or x1 x3))))) (and (not (and (or (and x5 x0) (not x0)) (or (or x8 x3) (or x0 x5)))) (and (or (or (and x6 x0) (not x1)) (or (or x3 x3) (or x2 x7))) (not (and (not x3) (or x0 x1))))))))) (not (and (and (or (or (not (and (not (or x2 x2)) (and (and x6 x2) (or x7 x6)))) (or (and (and (not x3) (not x7)) (or (not x8) (or x0 x0))) (and (not (or x7 x3)) (or (or x8 x6) (and x2 x1))))) (not (not (or (and (and x1 x1) (or x2 x3)) (not (not x0)))))) (not (not (not (or (or (or x8 x6) (and x7 x0)) (and (not x0) (not x7))))))) (or (and (and (or (not (not (not x7))) (and (or (and x2 x8) (or x2 x8)) (or (not x8) (or x6 x8)))) (or (and (and (and x6 x4) (not x0)) (or (or x2 x4) (or x8 x1))) (or (or (not x4) (not x8)) (or (or x8 x2) (and x8 x8))))) (and (not (not (or (and x0 x2) (not x5)))) (not (or (or (not x8) (and x8 x6)) (or (or x1 x6) (and x4 x6)))))) (not (and (or (not (or (not x8) (or x8 x4))) (or (and (or x6 x7) (or x5 x2)) (or (and x8 x2) (and x5 x0)))) (not (and (or (and x2 x1) (and x1 x5)) (or (not x7) (or x5 x4))))))))))) +(assert (or (and (or (and (and (not (and x5 x1)) (and (and x6 x6) (and x6 x4))) (not (not (and x4 x1)))) (and (or (not (or x5 x0)) (or (and x4 x0) (not x2))) (and (and (or x4 x3) (or x5 x4)) (and (or x0 x3) (and x2 x5))))) (and (and (and (not (or x7 x7)) (or (and x5 x4) (or x0 x2))) (not (not (or x7 x6)))) (and (not (or (and x4 x2) (and x4 x3))) (or (and (and x1 x5) (not x3)) (or (and x2 x0) (or x7 x2)))))) (or (or (and (or (not (and x2 x6)) (or (not x3) (and x6 x4))) (or (not (and x7 x0)) (not (or x3 x2)))) (and (or (and (and x4 x1) (or x6 x8)) (or (not x0) (or x0 x0))) (and (or (not x8) (not x7)) (or (or x7 x0) (not x7))))) (or (or (not (not (not x3))) (and (or (not x6) (and x0 x5)) (or (not x6) (and x6 x6)))) (not (and (and (not x6) (not x4)) (and (or x4 x4) (not x7)))))))) +(check-sat) +(push 1) +(assert (and (or (or x8 x0) (and x1 x0)) (and (and x6 x5) (not x3)))) +(assert (and x6 x2)) +(check-sat) +(pop 1) +(assert (and (and (or x0 x6) (not x3)) (or (and x7 x7) (and x7 x3)))) +(assert (not (not (not (or x5 x3))))) +(assert (not (and (and (and (not (and x2 x3)) (or (and x1 x5) (or x4 x2))) (or (or (or x4 x7) (and x5 x1)) (and (not x1) (and x1 x4)))) (or (or (and (not x6) (not x1)) (and (not x4) (or x6 x5))) (not (not (and x4 x8))))))) +(assert (and (or (not (and (not (or (or (or (not x2) (not x0)) (or (or x6 x0) (or x7 x6))) (or (or (or x2 x3) (not x5)) (and (and x4 x6) (and x3 x0))))) (and (and (or (not (not x3)) (or (not x6) (and x6 x1))) (not (and (not x4) (and x3 x5)))) (and (not (not (and x1 x8))) (or (or (not x5) (and x4 x7)) (and (and x5 x4) (or x8 x7))))))) (or (and (not (or (or (or (not x2) (not x2)) (not (or x5 x2))) (not (and (and x6 x5) (and x0 x1))))) (or (not (or (and (and x7 x8) (and x5 x3)) (not (and x6 x4)))) (not (not (and (not x6) (or x5 x0)))))) (or (not (not (not (or (not x7) (and x7 x5))))) (or (and (or (not (or x0 x3)) (not (and x0 x2))) (not (and (not x8) (not x7)))) (or (or (and (and x7 x5) (and x7 x5)) (or (or x4 x5) (not x4))) (and (or (or x4 x4) (and x8 x5)) (not (and x8 x3)))))))) (and (or (and (not (or (not (or (and x1 x6) (or x8 x3))) (not (not (not x8))))) (and (and (or (or (not x8) (and x2 x5)) (and (and x6 x4) (not x8))) (and (and (and x0 x7) (not x2)) (not (or x3 x6)))) (and (not (not (or x7 x8))) (not (not (or x0 x5)))))) (and (not (and (or (and (not x5) (and x4 x4)) (or (or x4 x1) (or x7 x7))) (and (and (and x3 x7) (not x7)) (or (not x2) (not x2))))) (not (not (or (not (or x7 x1)) (and (and x2 x8) (not x5))))))) (or (not (and (and (or (or (or x5 x5) (and x1 x5)) (not (and x4 x1))) (and (and (and x3 x0) (and x2 x5)) (not (or x6 x5)))) (or (or (and (or x8 x4) (not x3)) (and (not x6) (and x3 x7))) (and (and (not x0) (or x5 x5)) (or (not x5) (and x8 x1)))))) (and (or (not (and (and (not x6) (not x3)) (and (not x6) (or x5 x2)))) (not (or (or (or x8 x1) (and x8 x6)) (or (not x3) (or x8 x3))))) (not (or (and (and (and x2 x2) (not x5)) (not (and x8 x0))) (and (and (not x3) (not x1)) (and (and x2 x3) (not x6)))))))))) +(assert (or (or (and (and (not x7) (or x2 x6)) (or (and x3 x2) (and x8 x1))) (not (or (and x6 x5) (or x7 x1)))) (or (and (not (not x4)) (and (and x2 x5) (or x4 x1))) (not (not (or x7 x5)))))) +(assert (or (or (and (and (and (not (or (and x4 x7) (or x6 x2))) (and (or (and x2 x8) (or x2 x4)) (and (or x4 x2) (or x7 x7)))) (or (not (or (or x3 x2) (not x1))) (and (or (or x4 x8) (or x8 x1)) (and (not x6) (and x5 x1))))) (and (and (or (not (not x3)) (and (not x1) (and x1 x5))) (not (and (and x5 x4) (or x6 x7)))) (not (or (or (not x4) (and x2 x8)) (and (not x1) (or x3 x2)))))) (not (or (not (or (or (and x2 x4) (or x5 x6)) (not (not x8)))) (not (or (not (or x1 x5)) (not (or x4 x5))))))) (or (not (and (not (not (or (not x0) (and x7 x1)))) (and (or (and (or x0 x0) (or x5 x0)) (and (not x5) (or x5 x6))) (not (or (and x1 x5) (not x7)))))) (not (and (and (not (or (and x4 x8) (or x3 x8))) (not (or (or x6 x4) (not x5)))) (not (or (and (not x0) (not x2)) (or (or x4 x6) (or x0 x2))))))))) +(assert (not (and (and (or x3 x2) (or x1 x8)) (and (and x5 x5) (not x8))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (or (not (and (or (or (not (and (or x6 x3) (not x4))) (and (or (and x2 x3) (not x3)) (and (or x4 x1) (or x4 x3)))) (or (and (not (and x2 x5)) (and (and x2 x0) (and x5 x0))) (and (or (or x1 x4) (and x0 x0)) (or (and x1 x2) (not x5))))) (or (or (or (and (and x6 x5) (not x6)) (and (and x2 x3) (not x4))) (and (not (or x5 x0)) (or (and x1 x3) (and x1 x5)))) (and (not (or (and x0 x5) (and x2 x0))) (or (or (or x6 x2) (not x1)) (or (and x3 x6) (and x4 x2))))))) (and (not (or (or (not (not (or x4 x0))) (or (not (or x2 x4)) (and (not x2) (or x1 x3)))) (or (or (not (not x3)) (and (and x0 x4) (or x0 x0))) (not (and (not x0) (or x3 x2)))))) (or (or (or (or (and (not x3) (or x5 x6)) (and (or x6 x4) (or x5 x5))) (not (or (or x1 x2) (and x6 x4)))) (not (or (and (and x2 x4) (and x5 x2)) (and (not x5) (and x2 x1))))) (not (or (or (not (not x4)) (not (not x1))) (or (not (not x2)) (or (or x4 x6) (and x6 x1)))))))) (not (not (or (or (or (not (and (or x3 x2) (or x1 x4))) (and (or (and x3 x2) (and x4 x0)) (or (not x2) (and x2 x6)))) (and (not (and (and x3 x4) (not x1))) (or (not (and x3 x5)) (and (not x4) (or x5 x5))))) (not (or (or (or (or x6 x5) (or x1 x4)) (or (or x1 x4) (and x6 x0))) (not (not (not x6)))))))))) +(assert (or (and (or (and (or (and (not (and (and x5 x5) (not x6))) (not (not (not x3)))) (and (and (and (and x5 x0) (and x4 x3)) (not (and x2 x1))) (not (or (and x1 x3) (and x0 x6))))) (not (and (not (and (or x4 x1) (not x0))) (and (not (or x3 x3)) (or (or x4 x4) (not x3)))))) (or (or (not (or (and (or x3 x2) (or x3 x1)) (not (and x6 x4)))) (not (and (not (or x1 x6)) (or (not x2) (or x1 x6))))) (and (not (or (and (not x3) (and x1 x4)) (and (or x4 x1) (and x6 x6)))) (not (or (and (or x2 x2) (or x3 x1)) (or (not x2) (and x3 x1))))))) (and (not (and (not (not (or (and x6 x1) (and x1 x6)))) (or (or (and (or x5 x6) (not x5)) (or (and x5 x2) (not x5))) (and (or (and x1 x0) (or x6 x3)) (or (and x0 x5) (and x1 x3)))))) (or (and (not (or (not (or x3 x5)) (or (and x4 x2) (not x5)))) (and (not (or (not x6) (and x5 x4))) (and (or (not x3) (or x6 x3)) (not (and x1 x2))))) (and (not (and (not (or x5 x0)) (not (and x1 x3)))) (not (or (and (not x3) (or x0 x6)) (not (or x5 x3)))))))) (and (not (not (and (not (and (or (and x2 x3) (or x5 x6)) (and (not x0) (or x4 x1)))) (or (not (and (and x0 x4) (or x6 x4))) (and (not (or x3 x5)) (or (and x2 x1) (and x6 x3))))))) (not (not (not (or (and (not (or x1 x0)) (or (and x4 x1) (not x4))) (and (not (not x2)) (and (not x2) (and x3 x3)))))))))) +(check-sat) +(push 1) +(assert (or (not (not (not x6))) (and (or (and x1 x1) (not x2)) (and (or x4 x3) (not x1))))) +(assert (not (and (and x0 x3) (or x3 x4)))) +(assert (or (and x5 x3) (not x4))) +(assert (or (or (or (not (not (or (or (and x3 x2) (and x1 x2)) (and (or x5 x5) (not x6))))) (not (and (and (and (not x6) (or x1 x0)) (or (or x3 x3) (or x3 x3))) (and (or (and x0 x4) (not x3)) (or (not x1) (and x0 x6)))))) (and (and (or (or (not (and x6 x5)) (and (not x5) (or x6 x2))) (not (and (and x6 x2) (not x3)))) (not (or (or (not x5) (not x4)) (or (and x3 x6) (or x6 x1))))) (or (or (not (and (not x6) (or x1 x6))) (and (or (not x3) (and x1 x0)) (not (not x6)))) (not (not (not (not x2))))))) (not (and (and (or (not (not (not x2))) (or (and (not x3) (and x3 x4)) (not (and x1 x3)))) (or (or (and (not x0) (or x0 x0)) (or (not x3) (and x1 x0))) (not (not (and x5 x6))))) (and (and (and (not (not x2)) (not (or x6 x3))) (or (and (not x1) (not x1)) (and (and x1 x5) (and x2 x6)))) (not (not (and (not x1) (or x4 x5))))))))) +(assert (or (and (not (not (not (or (and (or (or x3 x5) (not x3)) (not (or x0 x5))) (or (or (not x3) (or x0 x2)) (or (not x3) (not x4))))))) (not (or (not (and (or (and (or x5 x1) (and x5 x2)) (not (not x5))) (not (or (not x1) (and x6 x6))))) (and (or (and (or (or x3 x1) (or x5 x4)) (and (not x2) (and x1 x2))) (and (or (and x0 x2) (and x6 x6)) (and (and x3 x4) (not x2)))) (or (and (not (not x2)) (and (not x3) (and x1 x5))) (and (not (or x1 x1)) (or (and x2 x5) (not x2)))))))) (and (or (not (not (not (and (and (not x4) (not x0)) (and (and x0 x3) (and x1 x0)))))) (and (or (not (and (and (or x2 x3) (not x2)) (or (not x2) (and x5 x4)))) (not (not (not (and x1 x4))))) (or (and (or (not (or x0 x4)) (and (not x4) (not x2))) (not (and (and x5 x0) (or x5 x1)))) (not (and (and (or x2 x4) (not x0)) (not (not x2))))))) (and (or (not (or (or (or (not x6) (not x1)) (not (or x6 x4))) (and (and (not x6) (not x4)) (not (and x3 x6))))) (not (not (not (not (not x1)))))) (not (or (or (and (not (and x4 x0)) (and (not x6) (or x4 x5))) (not (and (not x6) (or x5 x1)))) (or (and (or (or x1 x2) (or x5 x5)) (not (not x1))) (or (and (and x6 x6) (not x4)) (or (or x2 x0) (and x3 x0)))))))))) +(check-sat) +(pop 1) +(assert (or (and (not (and x2 x5)) (and (or x3 x4) (or x0 x3))) (or (or (not x1) (and x3 x3)) (not (or x5 x1))))) +(check-sat) +(push 1) +(assert (not (not (not (or (or x2 x3) (and x2 x1)))))) +(assert (not (and (not (and (or (or x4 x4) (or x1 x5)) (or (and x1 x1) (or x4 x3)))) (or (or (and (not x6) (not x6)) (and (not x1) (or x3 x6))) (not (not (and x4 x0))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (and (not (not (and (or (and x6 x6) (and x4 x4)) (or (or x2 x1) (or x0 x2))))) (and (and (not (or (and x0 x5) (or x2 x4))) (not (or (not x1) (not x1)))) (or (and (and (not x1) (not x3)) (not (or x4 x6))) (or (or (or x2 x6) (or x3 x4)) (and (and x3 x3) (or x0 x1)))))) (or (not (not (or (not (not x4)) (and (or x6 x0) (or x2 x0))))) (or (not (and (and (and x1 x3) (not x4)) (not (and x0 x1)))) (or (and (or (or x6 x4) (or x0 x6)) (or (or x6 x4) (not x4))) (and (not (or x5 x3)) (and (or x2 x2) (not x5)))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (or (not (or (or (or (or x1 x4) (and x3 x2)) (or (or x5 x1) (or x6 x2))) (or (not (and x3 x5)) (or (and x0 x1) (not x6))))) (and (and (and (or (and x3 x3) (or x2 x5)) (not (and x0 x4))) (not (not (not x4)))) (or (and (or (or x2 x1) (and x2 x2)) (not (or x1 x4))) (not (and (not x1) (and x0 x2)))))) (not (or (not (and (and (not x1) (and x3 x4)) (and (not x6) (or x6 x1)))) (not (not (and (or x2 x2) (and x4 x6))))))) (not (or (and (and (not (and (or x6 x5) (and x5 x2))) (not (or (not x4) (or x6 x1)))) (or (or (and (not x0) (not x4)) (or (and x4 x5) (not x4))) (or (and (or x6 x1) (and x3 x6)) (or (not x6) (or x4 x1))))) (not (or (and (and (or x2 x6) (not x3)) (or (or x3 x6) (or x1 x4))) (not (and (not x5) (not x0))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(assert (or (or (not (not x7)) (or (or x2 x5) (or x8 x5))) (and (or (and x7 x8) (not x3)) (and (or x5 x7) (or x5 x1))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (or (not x3) (or x4 x0)) (not (not x1))) (and (not (not x1)) (and (or x6 x8) (and x0 x8))))) +(assert (and (not (and x7 x6)) (not (and x7 x8)))) +(assert (or x6 x3)) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (not (not (not (or x1 x2))))) +(check-sat) +(pop 1) +(assert (or (or (and (not (not (or x8 x7))) (and (and (and x3 x8) (and x6 x0)) (not (and x1 x7)))) (or (or (not (not x4)) (or (and x0 x0) (and x6 x7))) (not (not (or x7 x5))))) (not (or (not (and (not x6) (not x1))) (or (or (and x3 x1) (not x6)) (or (and x5 x4) (not x4))))))) +(check-sat) +(push 1) +(assert (and (not x2) (not x5))) +(check-sat) +(push 1) +(assert (or (or (not (not (not (or (or (or x1 x5) (not x7)) (or (not x1) (or x4 x4)))))) (or (not (and (or (or (not x0) (or x8 x4)) (and (not x4) (or x5 x3))) (not (not (not x6))))) (not (or (and (or (or x4 x8) (not x8)) (and (or x8 x8) (or x6 x0))) (not (and (and x4 x0) (or x7 x5))))))) (or (not (or (and (and (not (and x1 x1)) (or (not x8) (not x5))) (and (not (and x0 x2)) (or (or x8 x4) (or x4 x6)))) (not (not (or (and x1 x7) (or x7 x0)))))) (not (not (and (and (and (or x4 x3) (or x0 x8)) (not (and x8 x7))) (or (or (not x1) (and x0 x5)) (and (or x8 x3) (and x4 x6))))))))) +(assert (or (and (and (not (not (and (or (not (and x3 x8)) (and (or x8 x0) (or x3 x5))) (not (or (or x7 x1) (and x6 x4)))))) (or (not (or (not (and (or x3 x8) (and x2 x1))) (and (not (or x6 x2)) (not (or x8 x6))))) (or (or (or (not (or x3 x6)) (not (not x1))) (or (or (and x4 x6) (or x6 x1)) (or (and x3 x3) (not x4)))) (or (or (and (or x0 x3) (or x6 x1)) (or (or x2 x5) (and x2 x4))) (or (not (not x1)) (not (or x5 x8))))))) (not (or (or (not (and (or (and x1 x4) (not x6)) (not (or x0 x7)))) (not (not (and (not x5) (or x4 x7))))) (or (and (and (not (or x8 x5)) (not (and x3 x6))) (and (and (not x1) (not x6)) (or (or x8 x8) (and x6 x1)))) (and (or (and (or x6 x5) (and x4 x6)) (or (or x1 x0) (or x1 x5))) (or (or (not x4) (not x3)) (not (or x1 x8)))))))) (not (or (and (and (not (or (not (or x3 x6)) (or (or x1 x1) (and x2 x0)))) (not (and (not (not x7)) (not (and x3 x4))))) (not (or (not (and (not x8) (not x5))) (and (or (not x6) (and x4 x3)) (not (not x2)))))) (and (or (not (not (or (or x1 x6) (not x5)))) (not (or (and (not x0) (and x1 x6)) (and (or x0 x5) (and x3 x0))))) (or (not (and (not (and x3 x7)) (and (or x0 x5) (and x1 x0)))) (and (or (not (not x3)) (and (or x7 x3) (or x8 x1))) (not (not (not x5)))))))))) +(check-sat) +(pop 7) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(check-sat) +(push 1) +(assert (or (and x1 x2) (and x1 x2))) +(assert (or (and (or (and (and (and (and (and (not (or x1 x2)) (not (and x0 x2))) (or (and (and x1 x2) (not x2)) (or (or x1 x2) (not x1)))) (or (or (not (not x1)) (or (and x0 x2) (or x2 x2))) (and (not (or x0 x0)) (not (and x1 x1))))) (not (not (and (not (not x2)) (and (or x1 x0) (and x0 x2)))))) (and (and (or (not (not (or x0 x2))) (not (or (not x2) (or x2 x0)))) (not (not (not (not x1))))) (or (not (and (not (and x1 x0)) (not (and x0 x1)))) (not (or (not (or x2 x2)) (or (not x2) (and x1 x0))))))) (not (not (or (not (not (or (and x0 x0) (and x1 x2)))) (not (and (or (and x2 x2) (or x2 x2)) (or (not x2) (or x1 x1)))))))) (or (not (and (or (not (or (and (and x0 x1) (or x0 x1)) (and (not x1) (and x1 x2)))) (or (and (not (and x1 x1)) (not (or x0 x2))) (not (not (not x2))))) (or (and (not (and (not x1) (and x2 x1))) (not (and (or x2 x1) (not x0)))) (or (or (not (or x1 x1)) (and (or x1 x2) (or x2 x1))) (or (and (or x1 x0) (and x2 x2)) (and (and x1 x0) (not x1))))))) (or (or (and (and (and (and (and x2 x0) (not x0)) (and (and x0 x1) (or x0 x2))) (not (or (and x1 x2) (or x1 x1)))) (and (or (not (not x1)) (not (or x1 x1))) (or (not (or x2 x0)) (not (and x2 x2))))) (and (and (or (not (and x1 x0)) (not (or x1 x0))) (and (not (not x1)) (and (not x1) (not x0)))) (not (or (and (not x1) (or x0 x1)) (and (or x0 x1) (not x2)))))) (and (or (or (not (or (and x0 x1) (not x0))) (not (and (not x1) (or x1 x2)))) (not (not (or (and x0 x1) (not x2))))) (or (or (or (not (not x2)) (and (or x0 x1) (and x1 x2))) (or (not (not x0)) (or (not x1) (and x1 x1)))) (or (and (and (not x2) (or x2 x2)) (not (not x0))) (and (not (or x0 x0)) (not (not x2))))))))) (and (and (or (or (not (or (and (not (and x2 x2)) (or (not x0) (or x0 x0))) (or (not (or x0 x0)) (and (not x2) (not x0))))) (or (and (or (or (or x2 x0) (and x2 x1)) (or (not x0) (not x1))) (and (or (not x1) (or x0 x2)) (or (or x0 x0) (not x0)))) (and (not (or (not x0) (and x2 x1))) (not (or (or x1 x1) (and x1 x1)))))) (and (not (not (and (not (and x2 x0)) (not (and x1 x2))))) (not (and (or (and (and x0 x0) (not x0)) (or (not x0) (or x2 x1))) (and (and (or x0 x2) (or x0 x2)) (and (or x1 x2) (not x0))))))) (and (not (or (or (not (and (and x0 x2) (and x0 x0))) (or (or (and x0 x0) (or x1 x1)) (or (and x2 x2) (or x0 x0)))) (or (or (not (or x2 x1)) (or (not x0) (or x1 x1))) (or (or (not x0) (and x0 x1)) (not (and x2 x1)))))) (not (or (not (or (or (or x0 x0) (or x2 x0)) (and (and x1 x0) (and x2 x0)))) (or (and (or (or x1 x1) (not x2)) (and (and x2 x0) (not x1))) (and (not (not x0)) (or (and x1 x1) (or x2 x2)))))))) (and (and (or (or (not (or (and (and x1 x1) (or x0 x2)) (not (and x0 x1)))) (not (or (and (and x0 x0) (and x1 x1)) (and (or x2 x0) (or x1 x2))))) (and (not (and (and (or x0 x0) (not x0)) (and (and x1 x2) (not x2)))) (and (or (and (or x1 x0) (or x0 x1)) (and (or x1 x2) (or x0 x1))) (and (not (and x0 x2)) (and (and x2 x0) (not x0)))))) (and (not (or (and (and (and x0 x1) (not x0)) (and (not x2) (not x2))) (and (and (and x2 x1) (not x1)) (not (or x2 x1))))) (not (and (and (and (not x0) (and x0 x2)) (not (and x2 x1))) (not (or (or x2 x0) (or x0 x2))))))) (not (and (not (or (or (and (or x2 x0) (or x1 x1)) (not (and x2 x0))) (not (not (not x0))))) (and (not (and (and (not x1) (and x2 x2)) (and (not x2) (not x1)))) (or (or (or (and x0 x0) (not x2)) (or (and x1 x2) (and x0 x2))) (or (or (and x2 x2) (or x2 x2)) (and (not x1) (or x1 x1))))))))))) +(assert (and x1 x2)) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (and (or (and (not x2) (or x0 x1)) (or (not x1) (not x2))) (or (or (not x2) (or x0 x2)) (and (not x1) (or x1 x2)))))) +(assert (not (and (and x1 x2) (or x1 x1)))) +(assert (or (not (not x2)) (not (and x0 x2)))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(assert (and (or (not (not (and x0 x4))) (and (not (not x2)) (not (not x4)))) (not (or (not (or x2 x5)) (and (not x4) (not x1)))))) +(assert (and (and (not (and (and (not (and (and (and x5 x0) (not x4)) (or (and x0 x0) (or x0 x0)))) (or (or (not (or x5 x2)) (or (not x3) (or x4 x2))) (not (and (and x1 x0) (not x0))))) (and (not (or (and (or x1 x3) (and x1 x0)) (and (and x2 x0) (and x2 x3)))) (not (not (or (not x5) (not x5))))))) (or (or (or (and (or (and (not x2) (or x1 x0)) (not (not x1))) (and (and (and x4 x3) (or x4 x3)) (and (not x5) (or x0 x2)))) (and (not (not (not x2))) (or (or (or x2 x1) (or x3 x2)) (and (or x2 x2) (and x4 x2))))) (not (or (or (and (or x1 x5) (or x3 x5)) (not (not x5))) (not (and (not x3) (not x3)))))) (not (or (and (or (or (or x4 x4) (or x0 x2)) (not (or x0 x4))) (or (or (or x2 x1) (or x1 x4)) (or (or x4 x4) (or x1 x5)))) (and (not (or (or x3 x4) (or x2 x0))) (not (not (or x2 x3)))))))) (and (or (or (not (not (not (and (not x2) (or x1 x2))))) (and (not (or (and (and x5 x3) (not x3)) (or (and x4 x0) (not x0)))) (not (not (and (and x0 x5) (and x3 x1)))))) (not (and (not (and (not (or x1 x3)) (not (or x1 x5)))) (not (not (not (or x1 x1))))))) (not (and (or (or (not (not (not x0))) (and (not (not x1)) (or (not x0) (or x4 x3)))) (or (and (or (and x4 x0) (and x1 x2)) (or (not x1) (not x5))) (or (or (or x3 x0) (or x3 x4)) (or (or x3 x4) (and x1 x2))))) (not (and (not (or (not x3) (not x3))) (and (and (or x5 x1) (not x2)) (or (or x5 x4) (or x0 x5)))))))))) +(check-sat) +(push 1) +(assert (and x0 x1)) +(check-sat) +(push 1) +(assert (and (or (and (and (or (or (not (or x4 x3)) (or (or x1 x0) (or x5 x3))) (and (or (not x0) (not x5)) (or (and x5 x0) (and x5 x0)))) (not (and (and (and x0 x1) (not x2)) (not (or x3 x3))))) (and (not (and (not (and x3 x1)) (not (not x1)))) (not (and (or (or x1 x0) (or x4 x4)) (or (not x5) (and x3 x4)))))) (or (not (or (not (or (and x3 x2) (or x0 x2))) (or (not (and x0 x0)) (and (not x4) (not x3))))) (not (or (and (and (or x5 x3) (and x2 x5)) (not (or x4 x4))) (or (not (not x1)) (or (or x3 x4) (not x5))))))) (not (and (and (not (not (or (not x0) (or x1 x4)))) (and (or (or (not x1) (not x5)) (not (or x2 x3))) (and (and (and x5 x3) (not x2)) (not (not x5))))) (or (or (and (and (and x0 x4) (not x5)) (not (or x0 x0))) (or (not (or x0 x4)) (and (not x1) (or x2 x0)))) (and (not (or (or x4 x2) (or x3 x3))) (and (and (and x5 x3) (and x4 x3)) (and (not x4) (not x1))))))))) +(check-sat) +(pop 1) +(assert (not (not (not (and (or (or (and (or x4 x3) (and x1 x4)) (and (or x3 x0) (not x0))) (and (and (or x1 x4) (and x3 x5)) (or (or x1 x5) (and x0 x1)))) (or (and (not (not x5)) (or (or x0 x2) (and x5 x0))) (and (or (not x2) (not x4)) (or (and x2 x5) (not x0))))))))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(assert (and (not (and (or (and (and (or (or (or x0 x1) (and x0 x0)) (or (not x0) (and x0 x1))) (or (not (or x0 x0)) (not (and x0 x0)))) (not (or (not (not x0)) (not (and x0 x1))))) (and (or (and (and (not x1) (or x1 x0)) (not (and x0 x1))) (not (not (or x1 x0)))) (not (not (and (or x0 x1) (not x0)))))) (and (not (or (and (and (not x1) (not x0)) (and (and x0 x1) (and x1 x1))) (and (not (and x0 x0)) (not (or x0 x0))))) (and (or (or (and (or x1 x1) (and x0 x1)) (not (or x0 x0))) (and (or (or x1 x1) (or x0 x0)) (and (or x1 x1) (and x0 x1)))) (not (or (and (not x0) (or x0 x1)) (or (and x0 x0) (or x0 x1)))))))) (or (not (and (and (and (not (and (not x0) (not x0))) (and (and (or x0 x1) (not x0)) (or (not x0) (or x0 x0)))) (and (and (and (not x0) (and x0 x1)) (and (not x0) (not x1))) (and (not (not x0)) (and (and x1 x1) (not x0))))) (or (not (not (not (not x0)))) (not (and (and (or x0 x1) (or x1 x1)) (or (or x1 x1) (or x0 x1))))))) (or (and (not (and (or (not (not x0)) (or (or x0 x1) (or x1 x0))) (or (and (not x1) (and x0 x1)) (or (not x1) (and x1 x0))))) (and (not (and (not (not x0)) (and (not x1) (and x1 x0)))) (not (not (and (or x0 x1) (or x0 x1)))))) (and (or (and (and (and (or x1 x0) (and x1 x0)) (and (not x1) (or x1 x1))) (or (and (and x1 x0) (not x1)) (and (not x1) (or x1 x1)))) (or (and (or (not x1) (not x1)) (and (or x0 x0) (not x0))) (not (and (not x0) (and x0 x1))))) (and (and (or (and (not x1) (or x0 x1)) (and (not x1) (or x1 x1))) (and (and (and x1 x1) (or x1 x0)) (and (not x0) (or x1 x1)))) (or (and (or (and x1 x0) (or x1 x1)) (or (or x1 x1) (and x1 x0))) (not (and (and x0 x1) (not x1)))))))))) +(assert (not (not (or (or (or (or (or (and x0 x0) (and x1 x0)) (or (and x1 x1) (and x0 x0))) (or (not (and x1 x1)) (and (or x1 x0) (or x0 x0)))) (and (and (or (and x1 x0) (or x1 x0)) (and (or x0 x1) (or x0 x0))) (and (not (not x0)) (and (and x1 x1) (or x1 x0))))) (and (not (not (and (or x0 x0) (and x1 x0)))) (not (or (or (and x1 x0) (or x0 x0)) (or (not x1) (and x1 x0))))))))) +(check-sat) +(push 1) +(assert (or (or (or (not (not (or x1 x1))) (not (not (and x0 x1)))) (and (not (not (not x0))) (not (and (not x0) (and x0 x1))))) (not (or (and (not (not x1)) (and (not x0) (or x1 x0))) (not (and (not x1) (and x1 x0))))))) +(assert (or x0 x0)) +(assert (and (not (and (or (or x0 x0) (and x1 x1)) (and (or x1 x0) (or x0 x1)))) (and (or (not (or x1 x1)) (not (not x0))) (or (or (and x1 x1) (not x1)) (not (or x0 x0)))))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(assert (or (and (not (or (or (or (and (or (and (and x7 x2) (or x6 x4)) (not (not x3))) (or (not (or x1 x2)) (and (or x1 x1) (and x5 x5)))) (or (and (and (or x2 x5) (and x6 x6)) (not (and x5 x6))) (and (and (and x5 x5) (or x1 x6)) (or (or x0 x3) (and x2 x4))))) (not (and (and (or (and x4 x4) (and x2 x4)) (or (and x0 x6) (or x6 x5))) (not (or (and x6 x7) (or x4 x4)))))) (and (not (or (or (or (not x6) (and x5 x6)) (or (and x2 x4) (or x6 x7))) (or (or (or x2 x5) (and x3 x6)) (or (and x5 x1) (and x1 x6))))) (and (not (and (and (not x1) (and x1 x7)) (and (or x2 x6) (or x0 x5)))) (and (not (and (not x4) (or x0 x2))) (and (not (and x4 x0)) (not (and x4 x1)))))))) (or (not (not (or (and (or (or (and x2 x7) (not x1)) (not (or x3 x7))) (and (not (not x4)) (or (or x7 x2) (and x3 x2)))) (or (or (and (or x2 x5) (or x0 x4)) (or (not x5) (not x5))) (and (not (and x0 x2)) (or (and x2 x7) (not x2))))))) (not (or (and (or (or (not (not x2)) (or (or x5 x2) (or x5 x7))) (and (and (or x0 x1) (or x7 x6)) (not (and x3 x0)))) (and (and (or (or x7 x5) (not x7)) (and (and x4 x5) (or x7 x2))) (or (or (not x1) (not x3)) (or (or x4 x7) (and x2 x0))))) (or (or (or (and (or x4 x6) (not x2)) (not (and x4 x4))) (not (or (and x2 x3) (not x1)))) (and (and (not (or x6 x3)) (not (or x4 x4))) (not (and (not x7) (and x2 x3))))))))) (or (not (or (or (and (and (not (or (and x0 x5) (and x7 x6))) (or (or (not x0) (not x3)) (or (and x0 x6) (or x7 x0)))) (or (or (and (not x4) (or x2 x3)) (not (not x7))) (not (and (and x2 x6) (not x0))))) (not (or (or (or (and x4 x2) (not x4)) (or (not x3) (and x5 x2))) (or (or (not x7) (not x1)) (not (and x1 x0)))))) (and (or (or (or (or (not x6) (and x3 x6)) (not (and x1 x0))) (or (or (and x7 x3) (not x1)) (not (or x7 x7)))) (and (or (or (not x1) (and x4 x2)) (or (not x3) (not x0))) (or (or (not x1) (not x7)) (not (or x1 x5))))) (or (or (and (and (not x0) (not x3)) (or (and x5 x4) (and x6 x0))) (or (or (and x4 x1) (and x7 x4)) (and (or x6 x0) (not x3)))) (not (and (or (not x4) (not x3)) (and (not x7) (not x7)))))))) (and (or (not (and (not (not (or (and x2 x6) (or x1 x2)))) (and (not (or (or x2 x4) (or x0 x4))) (or (or (and x2 x1) (and x1 x4)) (not (and x3 x0)))))) (and (not (not (and (and (not x3) (not x2)) (not (or x4 x6))))) (and (or (and (not (not x6)) (not (not x0))) (not (not (not x7)))) (and (not (not (and x6 x5))) (not (and (not x2) (or x5 x3))))))) (not (or (and (or (or (or (and x4 x3) (or x3 x6)) (and (and x4 x1) (or x4 x2))) (or (not (and x2 x6)) (or (not x0) (and x4 x5)))) (and (or (not (not x0)) (or (or x3 x7) (and x4 x2))) (or (not (and x0 x3)) (or (and x5 x0) (or x2 x3))))) (or (or (or (not (not x6)) (or (or x3 x1) (and x3 x4))) (and (or (or x0 x3) (or x3 x4)) (or (and x7 x0) (not x4)))) (or (not (not (and x7 x5))) (not (or (and x4 x3) (not x7))))))))))) +(assert (or (or x2 x1) (or x2 x4))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (or (and (not (or (or x5 x0) (or x7 x1))) (and (not (not x4)) (not (not x6)))) (not (not (or (or x4 x3) (not x2))))))) +(assert (and (and (and (and (not (not (and (or (and x7 x4) (and x7 x6)) (or (or x6 x5) (or x5 x3))))) (or (not (not (or (and x6 x6) (or x2 x6)))) (not (or (and (or x7 x5) (not x3)) (or (not x7) (not x0)))))) (or (or (and (or (not (not x1)) (and (or x0 x0) (and x4 x7))) (not (or (or x4 x5) (and x2 x5)))) (not (and (or (or x7 x0) (or x3 x1)) (not (and x3 x2))))) (and (not (and (not (or x4 x0)) (not (not x7)))) (and (not (not (and x1 x0))) (or (and (or x5 x5) (and x4 x5)) (not (not x6))))))) (not (and (or (not (or (or (and x0 x7) (not x0)) (or (and x7 x0) (and x0 x4)))) (and (not (not (not x0))) (or (and (not x3) (or x4 x2)) (not (and x1 x1))))) (and (and (or (or (and x0 x7) (or x0 x3)) (and (not x3) (or x4 x4))) (or (or (not x3) (or x7 x4)) (not (or x1 x2)))) (not (not (and (and x2 x5) (not x5)))))))) (not (not (and (or (and (or (not (not x3)) (or (or x0 x3) (and x3 x6))) (not (not (and x5 x4)))) (not (and (and (or x3 x7) (and x0 x2)) (or (and x5 x7) (not x1))))) (not (not (and (and (or x5 x3) (not x4)) (not (not x1)))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (not (not (and (or (or (and x3 x5) (or x2 x6)) (not (not x7))) (or (not (and x2 x7)) (or (and x0 x1) (or x6 x1)))))) (not (and (not (not (or (or x0 x7) (and x1 x1)))) (not (or (not (or x4 x4)) (or (or x1 x4) (and x3 x3))))))))) +(assert (or x5 x7)) +(check-sat) +(push 1) +(assert (and (or (not (not (or x5 x3))) (and (or (or x4 x5) (or x2 x1)) (and (not x5) (and x1 x3)))) (not (and (or (not x0) (not x7)) (not (not x5)))))) +(assert (or (and (not (and (or (and (or (and x2 x3) (not x4)) (or (and x1 x1) (or x3 x5))) (or (not (and x4 x7)) (and (and x1 x2) (or x4 x0)))) (and (not (not (or x0 x3))) (or (not (not x4)) (and (and x1 x5) (not x2)))))) (and (or (not (not (or (and x1 x5) (not x5)))) (and (or (and (not x6) (or x7 x3)) (or (and x7 x0) (and x4 x4))) (not (not (not x5))))) (and (and (not (and (and x2 x4) (or x4 x1))) (or (and (and x4 x0) (not x2)) (and (or x6 x2) (and x5 x2)))) (not (not (not (not x7))))))) (or (and (or (and (and (not (or x3 x4)) (and (not x5) (not x1))) (not (or (not x7) (or x5 x0)))) (and (not (and (and x1 x7) (or x7 x5))) (not (and (not x0) (or x2 x0))))) (not (and (or (or (not x1) (or x6 x6)) (and (and x5 x4) (or x5 x6))) (not (or (not x4) (and x5 x4)))))) (not (not (or (and (and (not x5) (not x2)) (and (not x3) (or x3 x2))) (not (and (not x5) (and x6 x1))))))))) +(assert (or (not (or (not (not (or (and (and (and x5 x4) (not x4)) (or (not x6) (and x2 x1))) (or (and (or x0 x7) (not x5)) (not (and x7 x4)))))) (not (and (and (or (and (or x7 x3) (not x3)) (or (not x5) (not x3))) (not (not (not x7)))) (not (or (not (or x2 x4)) (not (and x3 x0)))))))) (and (not (not (or (and (or (and (not x7) (not x1)) (not (not x4))) (not (and (or x4 x1) (or x3 x5)))) (or (not (and (not x3) (and x3 x6))) (and (not (or x0 x5)) (not (and x5 x6))))))) (or (not (not (not (and (not (and x4 x3)) (not (not x1)))))) (not (and (or (and (or (or x2 x7) (and x0 x7)) (or (and x7 x7) (and x7 x4))) (and (and (not x6) (or x2 x2)) (and (and x5 x3) (and x6 x2)))) (or (and (not (or x5 x3)) (or (or x3 x3) (or x1 x2))) (not (not (or x3 x1)))))))))) +(assert (not (or (or (and (and (and (or (and (or x5 x5) (or x6 x6)) (and (and x1 x2) (not x5))) (and (or (not x7) (or x1 x1)) (and (and x2 x2) (and x2 x5)))) (not (not (and (not x4) (not x1))))) (and (or (not (not (not x2))) (and (and (not x7) (or x4 x5)) (and (and x6 x2) (not x1)))) (not (and (not (or x4 x0)) (or (and x3 x4) (or x4 x6)))))) (and (and (or (and (not (not x5)) (not (not x6))) (or (not (not x0)) (and (or x5 x4) (not x5)))) (and (or (not (and x2 x3)) (and (or x7 x0) (and x6 x3))) (and (not (or x3 x4)) (or (or x2 x0) (not x0))))) (and (not (and (not (or x5 x3)) (not (or x5 x7)))) (and (or (not (and x7 x3)) (not (and x6 x6))) (or (or (not x0) (and x4 x2)) (not (and x3 x4))))))) (and (or (and (not (not (not (and x1 x3)))) (or (or (or (or x3 x3) (and x7 x1)) (or (not x5) (or x7 x6))) (and (or (and x0 x7) (or x4 x5)) (or (and x3 x1) (not x1))))) (or (and (and (not (and x6 x1)) (not (or x1 x2))) (and (not (not x4)) (and (or x0 x2) (or x0 x1)))) (or (not (and (not x4) (or x2 x2))) (and (and (or x1 x2) (not x7)) (and (and x0 x5) (or x2 x4)))))) (and (and (not (and (and (not x7) (not x5)) (or (and x4 x2) (and x6 x4)))) (and (or (not (not x2)) (and (not x1) (not x3))) (and (and (or x3 x0) (and x2 x2)) (or (not x7) (or x0 x4))))) (and (not (or (and (or x6 x4) (not x7)) (or (not x1) (and x2 x2)))) (and (or (or (not x5) (and x2 x1)) (or (not x7) (not x4))) (or (not (and x2 x7)) (or (not x5) (or x6 x7)))))))))) +(assert (not x0)) +(assert (and x0 x7)) +(assert (not (not (or (and x6 x2) (and x0 x6))))) +(assert (or (not x2) (and x5 x0))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (and (or (or x0 x0) (and x3 x5)) (not (not x4)))))) +(check-sat) +(pop 1) +(assert (and (not (or (and x6 x2) (not x4))) (not (and (or x1 x7) (or x0 x6))))) +(check-sat) +(pop 0) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(assert (not (not (or x0 x0)))) +(check-sat) +(push 1) +(assert (not (and (not (not (not (or (or x0 x0) (not x0))))) (not (not (and (and (or x0 x0) (and x0 x0)) (or (or x0 x0) (not x0)))))))) +(assert (or (not (not (not (and (not (not (or x0 x0))) (not (or (not x0) (not x0))))))) (and (not (or (or (and (and (and x0 x0) (or x0 x0)) (not (not x0))) (or (not (not x0)) (and (not x0) (and x0 x0)))) (or (not (or (not x0) (not x0))) (or (or (and x0 x0) (or x0 x0)) (and (and x0 x0) (and x0 x0)))))) (and (and (or (not (and (not x0) (and x0 x0))) (and (not (not x0)) (not (or x0 x0)))) (not (or (or (or x0 x0) (and x0 x0)) (not (not x0))))) (not (and (or (not (and x0 x0)) (or (or x0 x0) (or x0 x0))) (not (and (and x0 x0) (and x0 x0))))))))) +(assert (or (or (not (or (or x0 x0) (or x0 x0))) (or (or (and x0 x0) (or x0 x0)) (or (or x0 x0) (and x0 x0)))) (or (or (not (or x0 x0)) (or (or x0 x0) (not x0))) (or (not (and x0 x0)) (and (or x0 x0) (or x0 x0)))))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(check-sat) +(push 1) +(assert (not (and (or (and (and (or x0 x0) (or x0 x0)) (or (not x0) (and x0 x0))) (and (or (or x0 x0) (not x0)) (not (and x0 x0)))) (or (or (or (not x0) (or x0 x0)) (and (or x0 x0) (and x0 x0))) (or (or (not x0) (or x0 x0)) (not (or x0 x0))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (and (not (and (or (or (or (not (not x0)) (not (and x0 x0))) (or (not (and x0 x0)) (and (and x0 x0) (and x0 x0)))) (not (not (or (or x0 x0) (or x0 x0))))) (or (not (or (or (not x0) (not x0)) (not (or x0 x0)))) (not (not (and (and x0 x0) (and x0 x0))))))) (or (or (not (or (and (or (and x0 x0) (and x0 x0)) (not (or x0 x0))) (not (and (or x0 x0) (or x0 x0))))) (or (not (not (and (and x0 x0) (and x0 x0)))) (not (not (and (or x0 x0) (not x0)))))) (not (not (and (and (or (and x0 x0) (or x0 x0)) (and (or x0 x0) (not x0))) (not (not (or x0 x0)))))))) (and (or (or (or (and (and (not (and x0 x0)) (and (and x0 x0) (or x0 x0))) (or (and (not x0) (and x0 x0)) (and (not x0) (or x0 x0)))) (and (or (and (and x0 x0) (or x0 x0)) (or (or x0 x0) (and x0 x0))) (or (and (or x0 x0) (and x0 x0)) (or (and x0 x0) (not x0))))) (or (and (and (or (not x0) (not x0)) (and (not x0) (not x0))) (or (or (not x0) (and x0 x0)) (or (or x0 x0) (and x0 x0)))) (not (and (not (or x0 x0)) (not (not x0)))))) (or (not (not (or (not (or x0 x0)) (and (and x0 x0) (or x0 x0))))) (and (or (not (or (not x0) (or x0 x0))) (or (or (not x0) (or x0 x0)) (or (not x0) (or x0 x0)))) (and (not (or (not x0) (not x0))) (not (and (not x0) (or x0 x0))))))) (or (or (and (or (and (and (not x0) (and x0 x0)) (not (and x0 x0))) (not (not (not x0)))) (and (and (or (and x0 x0) (not x0)) (and (or x0 x0) (not x0))) (or (not (and x0 x0)) (not (and x0 x0))))) (and (or (or (not (not x0)) (and (not x0) (and x0 x0))) (not (or (and x0 x0) (or x0 x0)))) (not (and (not (not x0)) (not (and x0 x0)))))) (not (and (not (not (not (not x0)))) (or (not (not (or x0 x0))) (not (or (and x0 x0) (or x0 x0))))))))) (not (and (or (not (and (and (not (not (not x0))) (and (and (and x0 x0) (and x0 x0)) (and (not x0) (or x0 x0)))) (and (or (or (and x0 x0) (not x0)) (and (not x0) (not x0))) (or (not (or x0 x0)) (and (or x0 x0) (or x0 x0)))))) (not (and (or (or (and (and x0 x0) (not x0)) (and (not x0) (and x0 x0))) (or (not (and x0 x0)) (not (or x0 x0)))) (and (and (or (not x0) (and x0 x0)) (and (and x0 x0) (and x0 x0))) (and (or (or x0 x0) (or x0 x0)) (or (and x0 x0) (or x0 x0))))))) (and (or (and (and (or (and (and x0 x0) (not x0)) (or (and x0 x0) (not x0))) (and (and (not x0) (and x0 x0)) (not (or x0 x0)))) (or (and (or (and x0 x0) (and x0 x0)) (not (or x0 x0))) (not (or (and x0 x0) (or x0 x0))))) (and (or (or (and (or x0 x0) (or x0 x0)) (not (not x0))) (and (not (and x0 x0)) (not (not x0)))) (and (not (and (not x0) (not x0))) (and (or (and x0 x0) (and x0 x0)) (or (or x0 x0) (and x0 x0)))))) (and (and (or (not (not (and x0 x0))) (or (or (and x0 x0) (not x0)) (or (not x0) (or x0 x0)))) (not (or (and (not x0) (and x0 x0)) (or (and x0 x0) (or x0 x0))))) (not (or (or (not (not x0)) (or (not x0) (not x0))) (not (not (and x0 x0))))))))))) +(check-sat) +(push 1) +(assert (and (not (and (not (not (not x0))) (or (not (not x0)) (and (not x0) (or x0 x0))))) (or (not (not (or (not x0) (or x0 x0)))) (and (and (or (or x0 x0) (not x0)) (not (and x0 x0))) (not (or (not x0) (not x0))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (not (or (not (or (and (and (not (or (not (not x0)) (not (not x0)))) (and (not (not (or x0 x0))) (or (and (or x0 x0) (and x0 x0)) (and (or x0 x0) (and x0 x0))))) (or (not (or (and (not x0) (not x0)) (or (not x0) (not x0)))) (and (and (or (not x0) (and x0 x0)) (or (or x0 x0) (and x0 x0))) (not (not (and x0 x0)))))) (not (not (and (or (not (and x0 x0)) (or (or x0 x0) (and x0 x0))) (not (not (and x0 x0)))))))) (not (or (and (or (and (not (or (not x0) (and x0 x0))) (and (or (and x0 x0) (and x0 x0)) (not (or x0 x0)))) (or (and (or (not x0) (not x0)) (not (and x0 x0))) (or (and (and x0 x0) (not x0)) (and (or x0 x0) (and x0 x0))))) (and (or (and (and (or x0 x0) (not x0)) (or (or x0 x0) (and x0 x0))) (not (or (and x0 x0) (and x0 x0)))) (not (or (not (not x0)) (or (not x0) (not x0)))))) (or (or (or (and (or (and x0 x0) (not x0)) (not (not x0))) (and (not (or x0 x0)) (and (not x0) (not x0)))) (or (not (and (and x0 x0) (and x0 x0))) (and (not (not x0)) (and (or x0 x0) (not x0))))) (or (and (not (not (not x0))) (and (and (and x0 x0) (not x0)) (or (and x0 x0) (and x0 x0)))) (or (and (not (or x0 x0)) (and (and x0 x0) (not x0))) (or (not (not x0)) (and (or x0 x0) (or x0 x0))))))))))) +(check-sat) +(push 1) +(assert (and (or (not (not (and (and (not (not (not (and x0 x0)))) (not (not (and (or x0 x0) (not x0))))) (and (or (or (and (or x0 x0) (or x0 x0)) (or (not x0) (or x0 x0))) (and (and (and x0 x0) (not x0)) (or (not x0) (or x0 x0)))) (or (not (and (and x0 x0) (not x0))) (not (not (not x0)))))))) (or (and (and (and (or (or (not (not x0)) (and (or x0 x0) (or x0 x0))) (and (and (and x0 x0) (or x0 x0)) (and (not x0) (or x0 x0)))) (or (or (not (not x0)) (or (or x0 x0) (and x0 x0))) (or (or (and x0 x0) (or x0 x0)) (not (and x0 x0))))) (not (or (not (or (and x0 x0) (not x0))) (and (and (not x0) (not x0)) (or (not x0) (or x0 x0)))))) (not (and (and (not (and (or x0 x0) (not x0))) (and (or (or x0 x0) (or x0 x0)) (or (and x0 x0) (or x0 x0)))) (or (or (not (not x0)) (and (not x0) (and x0 x0))) (and (and (or x0 x0) (or x0 x0)) (and (and x0 x0) (not x0))))))) (not (or (or (and (not (and (and x0 x0) (and x0 x0))) (or (or (or x0 x0) (or x0 x0)) (and (and x0 x0) (not x0)))) (not (not (or (or x0 x0) (or x0 x0))))) (not (or (or (or (and x0 x0) (not x0)) (not (or x0 x0))) (or (not (or x0 x0)) (and (and x0 x0) (or x0 x0))))))))) (or (or (and (not (not (not (and (or (or x0 x0) (not x0)) (and (not x0) (not x0)))))) (or (or (not (and (not (and x0 x0)) (not (and x0 x0)))) (not (not (not (or x0 x0))))) (or (and (or (or (or x0 x0) (not x0)) (or (and x0 x0) (not x0))) (or (and (not x0) (and x0 x0)) (not (not x0)))) (not (or (and (not x0) (and x0 x0)) (and (not x0) (and x0 x0))))))) (or (not (and (and (or (or (or x0 x0) (or x0 x0)) (not (not x0))) (or (and (not x0) (and x0 x0)) (not (and x0 x0)))) (or (or (not (not x0)) (or (and x0 x0) (and x0 x0))) (not (and (not x0) (and x0 x0)))))) (or (and (or (not (and (and x0 x0) (and x0 x0))) (not (or (not x0) (or x0 x0)))) (and (not (and (or x0 x0) (or x0 x0))) (or (or (not x0) (or x0 x0)) (or (and x0 x0) (or x0 x0))))) (not (or (and (or (not x0) (and x0 x0)) (and (and x0 x0) (or x0 x0))) (not (and (or x0 x0) (and x0 x0)))))))) (not (or (and (or (or (or (and (or x0 x0) (and x0 x0)) (and (not x0) (or x0 x0))) (and (or (or x0 x0) (not x0)) (or (or x0 x0) (and x0 x0)))) (not (or (and (or x0 x0) (or x0 x0)) (or (or x0 x0) (or x0 x0))))) (or (not (and (and (or x0 x0) (or x0 x0)) (or (and x0 x0) (not x0)))) (and (not (and (or x0 x0) (not x0))) (and (and (or x0 x0) (and x0 x0)) (and (not x0) (not x0)))))) (and (not (or (or (or (and x0 x0) (not x0)) (or (not x0) (or x0 x0))) (and (and (not x0) (not x0)) (not (not x0))))) (not (or (not (and (not x0) (or x0 x0))) (or (or (not x0) (and x0 x0)) (not (and x0 x0))))))))))) +(assert (or (not (and (or x0 x0) (or x0 x0))) (or (not (or x0 x0)) (not (not x0))))) +(assert (not (and (not (and (or (and (or x0 x0) (and x0 x0)) (not (and x0 x0))) (not (not (or x0 x0))))) (and (and (not (or (not x0) (not x0))) (and (or (and x0 x0) (or x0 x0)) (and (not x0) (not x0)))) (or (and (and (and x0 x0) (and x0 x0)) (or (not x0) (not x0))) (and (and (or x0 x0) (or x0 x0)) (or (not x0) (not x0)))))))) +(check-sat) +(pop 4) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(assert (not (and (not x3) (or x2 x1)))) +(assert (or (not (or (and (not (or (or (or (not x2) (not x7)) (and (or x7 x4) (or x6 x7))) (not (not (or x6 x4))))) (not (or (or (and (or x1 x5) (and x4 x7)) (or (and x4 x6) (and x0 x0))) (not (and (and x5 x7) (and x0 x5)))))) (and (or (not (and (not (or x1 x7)) (and (or x1 x5) (and x6 x1)))) (or (and (not (not x5)) (not (not x5))) (and (or (or x0 x5) (and x1 x3)) (or (or x0 x6) (and x2 x7))))) (not (or (not (and (and x0 x4) (not x2))) (not (and (or x1 x3) (not x7)))))))) (not (and (and (not (or (or (or (not x7) (and x0 x5)) (not (or x4 x3))) (or (and (and x3 x1) (and x7 x4)) (or (and x5 x4) (not x6))))) (not (not (or (or (not x1) (or x7 x1)) (and (or x1 x5) (or x3 x1)))))) (or (and (not (and (and (and x2 x7) (or x4 x5)) (not (or x6 x4)))) (not (and (or (or x5 x2) (and x4 x3)) (or (or x4 x0) (and x0 x1))))) (not (and (and (and (not x1) (or x2 x1)) (not (or x7 x6))) (not (or (and x4 x4) (not x2)))))))))) +(assert (and (or (and (not (or (and (and (or (not x0) (and x1 x7)) (and (not x0) (or x4 x5))) (or (or (and x6 x7) (or x3 x3)) (or (or x2 x2) (and x5 x6)))) (not (not (and (or x3 x6) (and x6 x0)))))) (and (not (not (not (not (and x7 x6))))) (or (not (or (not (or x7 x4)) (or (or x7 x4) (or x4 x2)))) (not (and (and (not x3) (or x3 x1)) (not (or x5 x4))))))) (and (and (and (not (not (and (not x5) (and x7 x5)))) (not (not (and (not x4) (and x5 x6))))) (or (not (and (and (or x4 x3) (not x6)) (and (and x2 x5) (or x5 x2)))) (or (and (or (and x0 x1) (not x3)) (or (not x4) (or x0 x2))) (not (or (not x6) (not x0)))))) (not (not (or (and (and (and x3 x0) (not x0)) (not (not x3))) (not (and (and x5 x3) (not x7)))))))) (and (or (not (and (or (and (and (not x0) (or x4 x2)) (or (and x3 x0) (or x6 x0))) (or (or (not x6) (not x7)) (not (and x5 x0)))) (and (not (or (and x1 x5) (not x2))) (or (not (and x3 x4)) (and (and x2 x0) (and x1 x6)))))) (not (and (or (and (and (or x5 x5) (not x2)) (or (or x6 x7) (or x7 x5))) (not (and (and x0 x4) (or x5 x1)))) (and (or (or (not x0) (or x7 x2)) (or (not x3) (and x1 x0))) (or (not (not x3)) (and (or x0 x0) (and x0 x2))))))) (or (or (and (and (and (and (not x5) (and x7 x6)) (and (and x0 x2) (or x3 x4))) (not (and (not x7) (or x3 x1)))) (and (not (or (or x4 x3) (or x5 x1))) (not (and (and x0 x0) (or x7 x6))))) (not (and (not (not (and x2 x6))) (and (and (or x3 x6) (or x4 x3)) (or (and x2 x1) (and x7 x6)))))) (and (not (and (and (not (not x3)) (not (or x3 x1))) (not (or (or x2 x3) (not x0))))) (not (or (not (or (and x2 x1) (or x4 x2))) (not (or (not x4) (or x2 x7)))))))))) +(check-sat) +(push 1) +(assert (not (not (not (or (and (or (and x6 x5) (or x6 x7)) (or (not x2) (not x7))) (or (or (and x6 x3) (and x7 x7)) (or (and x6 x4) (or x0 x6)))))))) +(assert (not (or (not (and (not (or (not (and (or x0 x1) (not x1))) (or (or (and x3 x1) (and x2 x0)) (or (and x1 x3) (or x7 x3))))) (or (or (and (and (not x2) (not x0)) (and (not x4) (not x2))) (not (and (not x6) (not x7)))) (not (not (not (or x0 x2))))))) (and (and (or (not (or (and (or x4 x2) (and x6 x4)) (and (or x4 x3) (and x1 x6)))) (and (or (or (not x5) (and x1 x5)) (and (and x6 x0) (not x0))) (or (and (or x5 x2) (and x7 x4)) (not (not x6))))) (or (and (or (not (or x7 x4)) (and (and x3 x3) (or x4 x0))) (not (not (or x0 x3)))) (or (not (not (and x3 x2))) (or (not (or x1 x6)) (or (and x5 x6) (and x6 x6)))))) (or (and (and (or (and (or x3 x7) (not x4)) (not (not x0))) (or (not (and x4 x3)) (not (and x6 x1)))) (not (not (or (and x1 x5) (and x7 x3))))) (and (or (or (not (and x4 x0)) (or (and x5 x0) (or x5 x4))) (or (and (and x6 x7) (not x4)) (and (not x0) (and x3 x1)))) (or (not (or (not x6) (or x2 x4))) (or (or (or x1 x5) (not x1)) (or (not x5) (and x3 x6)))))))))) +(assert (not (or (not (not x4)) (and (and x5 x0) (and x6 x7))))) +(assert (not (not (and (and (or (not x5) (or x4 x5)) (or (and x7 x5) (or x7 x0))) (not (not (and x1 x7))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (or x0 x6)) (not (and x1 x7)))) +(check-sat) +(push 1) +(assert (or (and (not x7) (not x4)) (or (not x3) (or x7 x7)))) +(assert (not (and (or (and (not (or (and (not (and (and x0 x0) (and x3 x3))) (and (and (not x3) (or x2 x5)) (not (not x0)))) (not (not (or (or x3 x5) (not x4)))))) (and (not (not (not (or (or x3 x4) (or x3 x6))))) (not (or (or (or (or x5 x1) (not x2)) (and (not x3) (and x1 x2))) (not (and (not x5) (and x1 x5))))))) (not (and (or (not (not (or (or x3 x0) (not x2)))) (and (or (or (and x2 x6) (or x5 x6)) (and (or x7 x7) (not x3))) (not (not (and x0 x7))))) (or (or (and (or (not x7) (or x0 x0)) (and (and x2 x4) (not x1))) (not (or (not x3) (and x7 x2)))) (and (not (and (or x4 x0) (not x4))) (not (or (or x5 x7) (or x5 x3)))))))) (or (not (not (and (or (and (not (or x0 x2)) (not (and x4 x1))) (or (not (and x4 x3)) (and (or x4 x0) (not x0)))) (and (or (or (not x7) (and x7 x4)) (and (and x3 x3) (or x3 x4))) (or (or (or x7 x7) (or x5 x7)) (not (not x3))))))) (not (not (or (not (not (and (and x3 x6) (not x5)))) (and (and (or (or x6 x2) (and x2 x6)) (not (or x6 x0))) (not (and (or x6 x6) (not x1))))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (or (and (or (not x6) (and x4 x4)) (not (and x3 x3))) (and (not (or x2 x4)) (and (not x1) (or x4 x6)))))) +(check-sat) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (or (not (not (and (and x3 x0) (not x2)))) (and (not (not (and x1 x6))) (and (and (or x1 x4) (or x0 x3)) (or (or x0 x4) (or x3 x3))))) (and (and (not (not (or x5 x3))) (or (or (and x5 x1) (not x4)) (and (or x4 x3) (and x4 x5)))) (not (or (not (not x6)) (or (not x0) (not x6))))))) +(check-sat) +(push 1) +(assert (not (not (or (not (not (and (and x6 x1) (or x2 x1)))) (and (or (not (or x1 x0)) (or (not x1) (or x3 x6))) (or (not (and x3 x1)) (not (not x1)))))))) +(assert (or (not (not (or x4 x3))) (or (not (and x4 x4)) (not (or x3 x5))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (or (not (not (and (and (not (not (not x5))) (and (not (and x5 x4)) (not (or x1 x0)))) (not (and (or (or x2 x4) (not x4)) (or (and x3 x6) (and x6 x2))))))) (and (and (not (and (or (not (or x1 x2)) (not (or x6 x1))) (or (and (not x3) (or x3 x5)) (or (and x4 x4) (and x6 x6))))) (not (and (not (or (or x3 x2) (not x2))) (not (or (not x2) (not x6)))))) (or (not (or (not (not (or x4 x3))) (and (and (and x2 x6) (or x6 x5)) (or (or x1 x3) (and x2 x3))))) (or (and (and (or (and x6 x0) (and x5 x1)) (not (not x1))) (or (or (and x0 x2) (not x0)) (not (or x0 x5)))) (and (not (and (not x2) (not x2))) (not (or (not x3) (not x5)))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (and (and (and (or (not (not (and (not x1) (not x2)))) (not (and (not (and x0 x4)) (and (not x3) (or x5 x1))))) (or (or (and (or (and x3 x6) (and x3 x1)) (not (or x1 x4))) (and (or (not x5) (not x0)) (not (not x3)))) (or (and (and (or x6 x5) (and x5 x5)) (or (and x1 x6) (and x5 x6))) (or (and (or x5 x6) (or x5 x4)) (not (or x2 x0)))))) (or (and (and (and (or (or x4 x2) (or x5 x1)) (and (or x5 x0) (and x5 x5))) (not (and (not x5) (or x3 x1)))) (not (and (and (or x5 x1) (and x0 x2)) (not (and x6 x3))))) (and (not (or (not (or x2 x2)) (and (or x0 x2) (not x0)))) (not (or (not (not x3)) (not (and x4 x6))))))) (or (not (or (or (or (or (not x3) (or x0 x3)) (not (and x0 x6))) (or (and (or x2 x4) (or x2 x6)) (and (or x3 x0) (not x6)))) (and (or (and (or x1 x4) (not x3)) (and (not x2) (not x0))) (not (or (not x5) (not x2)))))) (not (or (not (or (or (and x3 x2) (or x3 x6)) (and (and x1 x2) (or x1 x6)))) (not (and (or (not x4) (not x2)) (not (and x0 x0)))))))) (or (not (and (or (not (and (and (or x3 x4) (and x4 x1)) (not (not x1)))) (not (not (not (or x0 x2))))) (and (not (or (and (or x6 x2) (not x5)) (and (and x6 x6) (or x6 x6)))) (and (and (or (or x2 x2) (or x2 x1)) (or (not x1) (and x4 x1))) (or (or (not x4) (and x5 x6)) (or (not x0) (not x2))))))) (not (not (not (or (not (and (or x0 x5) (and x4 x0))) (not (not (and x3 x3))))))))) (or (and (not (not (or (and (or (not (and x3 x2)) (not (and x2 x3))) (not (or (not x2) (and x4 x0)))) (or (and (and (not x3) (and x6 x5)) (or (and x3 x3) (or x5 x0))) (not (or (or x4 x5) (or x2 x1))))))) (or (or (or (not (not (not (or x4 x4)))) (and (not (or (or x0 x4) (and x1 x3))) (and (not (and x5 x4)) (or (not x5) (not x5))))) (or (or (not (or (and x3 x6) (and x6 x1))) (not (or (and x5 x1) (not x5)))) (and (or (or (not x4) (not x4)) (and (and x2 x2) (or x4 x0))) (and (not (or x5 x2)) (or (not x5) (or x3 x5)))))) (not (and (not (and (and (not x0) (not x3)) (not (or x2 x2)))) (and (or (or (and x4 x6) (not x1)) (and (not x4) (or x3 x6))) (or (and (or x0 x1) (and x1 x4)) (or (and x4 x2) (and x2 x0)))))))) (and (or (or (not (and (or (or (or x2 x2) (not x1)) (and (or x4 x3) (or x1 x3))) (or (or (or x4 x0) (not x2)) (or (and x1 x3) (or x2 x5))))) (and (or (and (and (and x3 x3) (and x3 x4)) (not (and x6 x3))) (not (or (or x6 x1) (or x1 x6)))) (or (or (or (not x2) (not x0)) (or (and x6 x6) (not x6))) (not (not (not x0)))))) (and (not (or (or (and (and x1 x1) (and x6 x2)) (or (not x2) (and x2 x2))) (and (not (or x0 x5)) (and (not x4) (not x4))))) (or (not (and (and (or x0 x3) (and x2 x6)) (not (not x0)))) (not (or (not (and x3 x3)) (or (not x5) (and x1 x6))))))) (not (or (or (and (not (not (not x4))) (and (and (not x3) (and x4 x3)) (not (or x4 x2)))) (or (not (or (and x2 x6) (or x5 x2))) (and (not (or x6 x6)) (not (not x0))))) (and (not (and (or (or x4 x3) (and x1 x4)) (and (or x1 x6) (or x0 x1)))) (or (or (and (or x5 x1) (not x3)) (or (not x0) (or x1 x5))) (or (and (or x3 x6) (not x0)) (or (not x2) (or x2 x4))))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (and (not (not x0)) (and (and x0 x1) (or x2 x1))) (not (and (not x4) (or x6 x0))))) +(assert (not (not (and (or (or (and (and (or x4 x6) (or x3 x1)) (not (and x4 x5))) (or (not (not x3)) (and (not x6) (and x3 x6)))) (and (and (not (not x0)) (not (and x5 x5))) (or (not (or x1 x0)) (and (and x2 x3) (not x6))))) (or (and (and (not (or x0 x2)) (and (not x4) (or x3 x1))) (not (or (not x6) (and x4 x4)))) (not (not (not (and x6 x2))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (and (or (and (or (or (or (or (and (and x1 x4) (or x0 x0)) (or (not x3) (or x1 x4))) (not (not (and x6 x0)))) (or (and (and (or x1 x4) (not x4)) (or (not x1) (or x1 x0))) (and (or (not x6) (and x5 x2)) (and (not x2) (not x1))))) (or (and (not (and (and x2 x2) (not x3))) (not (or (or x4 x2) (not x5)))) (not (not (or (or x1 x1) (and x0 x4)))))) (or (or (or (and (not (and x1 x6)) (and (and x6 x2) (and x3 x3))) (not (not (or x5 x4)))) (or (or (not (or x6 x4)) (or (not x0) (not x4))) (not (or (and x4 x4) (not x3))))) (or (or (not (not (or x3 x2))) (or (or (and x6 x0) (not x2)) (and (not x5) (or x6 x0)))) (or (not (and (and x2 x3) (not x6))) (or (not (and x0 x4)) (or (or x3 x6) (not x1))))))) (not (and (or (and (and (or (not x2) (or x0 x6)) (not (and x5 x4))) (not (not (not x1)))) (not (or (or (or x5 x0) (not x4)) (not (not x4))))) (and (and (or (not (not x0)) (not (or x0 x3))) (or (and (or x1 x4) (and x3 x5)) (not (not x1)))) (not (or (not (and x4 x2)) (and (and x0 x2) (not x2)))))))) (and (and (or (and (or (or (and (not x4) (or x6 x3)) (not (not x5))) (and (and (and x2 x0) (or x2 x2)) (not (and x0 x0)))) (or (not (or (and x3 x4) (and x4 x0))) (or (not (not x0)) (not (not x3))))) (not (and (and (or (and x0 x2) (or x4 x4)) (and (and x4 x6) (not x0))) (or (not (or x0 x3)) (or (not x1) (or x3 x1)))))) (not (not (not (not (not (not x0))))))) (and (or (or (not (and (not (or x6 x3)) (not (and x4 x0)))) (not (and (and (not x4) (and x1 x3)) (not (not x5))))) (not (not (or (or (not x4) (not x1)) (or (not x3) (not x4)))))) (and (or (and (and (not (and x4 x5)) (or (and x0 x5) (or x6 x1))) (and (and (and x0 x1) (not x1)) (or (not x5) (and x5 x2)))) (not (or (or (and x4 x4) (or x5 x4)) (not (or x0 x4))))) (not (and (not (and (or x3 x6) (and x1 x1))) (or (or (or x1 x6) (or x6 x0)) (or (or x6 x0) (not x2))))))))) (or (and (and (or (and (or (not (not (not x1))) (and (not (or x6 x0)) (and (not x1) (not x1)))) (or (or (not (or x2 x6)) (and (or x4 x1) (or x0 x1))) (or (and (and x0 x6) (or x6 x0)) (or (and x2 x3) (or x4 x1))))) (or (not (and (not (or x2 x3)) (not (or x2 x4)))) (or (not (not (not x2))) (not (or (or x1 x4) (and x6 x2)))))) (not (or (or (not (and (or x3 x1) (or x4 x5))) (not (or (or x6 x5) (and x1 x6)))) (and (and (or (or x4 x4) (and x6 x6)) (and (and x2 x5) (not x5))) (or (or (not x2) (and x5 x6)) (or (not x3) (and x5 x6))))))) (or (and (or (not (or (and (or x5 x6) (and x2 x5)) (or (and x5 x3) (or x1 x2)))) (and (or (and (or x1 x2) (or x6 x5)) (and (not x5) (not x2))) (not (and (not x5) (not x0))))) (or (and (and (and (not x5) (and x5 x0)) (or (or x6 x6) (not x2))) (and (not (or x6 x1)) (not (and x6 x4)))) (or (not (and (not x4) (and x5 x6))) (or (or (or x1 x2) (not x5)) (not (or x3 x5)))))) (not (and (not (and (and (not x4) (or x4 x6)) (not (not x1)))) (not (and (or (or x0 x4) (not x4)) (and (or x5 x2) (not x1)))))))) (or (not (not (not (not (or (and (or x1 x4) (or x1 x2)) (not (not x1))))))) (and (not (not (and (or (or (and x0 x2) (not x4)) (or (or x5 x0) (or x6 x3))) (or (or (or x1 x3) (not x5)) (and (not x5) (and x4 x0)))))) (or (not (not (and (or (or x4 x4) (and x1 x6)) (not (not x2))))) (not (or (not (and (or x4 x0) (and x5 x1))) (and (and (and x3 x0) (not x1)) (and (and x6 x0) (not x1))))))))))) +(assert (or (or (and (not (not (and (not x3) (or x3 x3)))) (or (or (not (or x1 x6)) (and (and x2 x6) (or x1 x0))) (or (not (and x5 x0)) (or (or x6 x0) (not x0))))) (or (or (not (and (and x5 x4) (not x5))) (or (or (or x4 x1) (and x4 x0)) (or (not x0) (or x5 x6)))) (not (or (or (or x3 x1) (or x3 x6)) (or (or x1 x5) (or x5 x6)))))) (or (not (or (or (and (not x2) (and x0 x0)) (or (or x2 x6) (and x5 x5))) (or (or (not x6) (and x2 x3)) (not (and x4 x4))))) (and (and (or (not (and x3 x5)) (or (and x6 x4) (and x6 x6))) (not (or (not x6) (and x1 x2)))) (not (not (and (and x0 x4) (and x1 x0)))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (and x6 x6)))) +(check-sat) +(pop 1) +(assert (not (or (or (or x6 x6) (or x1 x5)) (and (not x2) (and x2 x3))))) +(check-sat) +(push 1) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (and (or (or (or (not (and (and (or (and x2 x1) (and x0 x4)) (and (and x0 x2) (not x1))) (or (not (not x3)) (not (and x6 x0))))) (and (and (or (or (and x2 x0) (and x0 x0)) (and (and x1 x6) (not x6))) (or (not (and x1 x4)) (or (or x0 x0) (or x3 x0)))) (not (or (or (and x1 x2) (and x1 x4)) (not (and x3 x2)))))) (or (or (and (and (and (or x1 x4) (not x1)) (or (not x1) (and x4 x5))) (and (not (or x3 x2)) (and (not x4) (not x6)))) (or (not (not (not x6))) (not (not (or x0 x2))))) (and (and (or (or (or x6 x3) (or x3 x1)) (not (and x4 x1))) (and (not (or x1 x3)) (or (or x3 x4) (or x4 x1)))) (or (not (or (not x0) (and x4 x5))) (not (not (or x4 x4))))))) (or (not (or (or (and (or (not x1) (and x3 x3)) (not (or x4 x0))) (and (and (not x6) (and x6 x3)) (and (not x1) (not x6)))) (or (or (not (and x5 x0)) (or (not x1) (or x3 x0))) (and (not (and x0 x0)) (and (and x5 x6) (not x2)))))) (and (not (and (not (not (not x0))) (and (or (and x2 x2) (or x1 x4)) (or (and x1 x6) (and x5 x3))))) (and (not (not (not (or x0 x0)))) (or (or (and (or x0 x2) (or x5 x2)) (not (not x2))) (not (or (and x3 x2) (or x5 x3)))))))) (or (and (or (or (not (not (or (not x6) (and x1 x2)))) (not (and (not (and x1 x3)) (and (not x2) (and x1 x4))))) (not (or (and (and (or x1 x2) (or x0 x2)) (and (or x6 x6) (and x4 x0))) (and (and (or x0 x4) (or x6 x0)) (and (and x0 x2) (or x3 x6)))))) (or (and (or (or (and (and x4 x6) (or x2 x6)) (and (not x6) (or x6 x1))) (not (not (not x3)))) (or (and (not (and x5 x2)) (or (or x5 x1) (or x4 x6))) (and (not (or x3 x4)) (or (not x2) (not x2))))) (or (or (not (not (or x1 x1))) (and (not (or x6 x4)) (and (or x6 x1) (not x5)))) (and (and (not (or x0 x0)) (and (or x0 x6) (not x6))) (or (and (not x0) (or x2 x1)) (or (and x6 x3) (not x3))))))) (not (or (not (not (or (or (and x3 x0) (and x3 x5)) (and (or x3 x0) (and x3 x0))))) (not (or (not (or (or x6 x4) (not x5))) (not (or (and x5 x2) (and x4 x4)))))))))) +(assert (or x3 x5)) +(assert (or (and (not x1) (not x6)) (not (not x6)))) +(assert (not (not (and (and (or (or (and (not (or (or x0 x4) (and x4 x1))) (and (and (or x4 x5) (or x3 x1)) (or (not x0) (or x3 x4)))) (or (or (or (or x5 x5) (or x1 x4)) (or (and x5 x6) (not x1))) (or (or (or x2 x0) (or x0 x3)) (and (or x0 x4) (or x5 x6))))) (not (or (not (not (or x0 x2))) (and (and (and x0 x1) (and x0 x5)) (not (and x6 x0)))))) (and (not (or (not (or (or x2 x3) (and x6 x6))) (and (or (not x1) (or x2 x6)) (or (and x6 x4) (and x6 x5))))) (not (not (not (and (not x5) (or x1 x4))))))) (or (not (or (not (not (or (or x4 x0) (and x2 x6)))) (and (and (not (not x0)) (not (not x2))) (not (not (and x5 x6)))))) (or (and (and (and (or (not x4) (not x1)) (and (not x3) (not x1))) (not (and (not x1) (not x0)))) (or (or (or (or x3 x3) (not x3)) (or (not x0) (and x5 x5))) (or (not (and x0 x6)) (and (and x6 x1) (or x0 x3))))) (not (or (or (and (and x1 x5) (and x3 x6)) (and (not x0) (not x4))) (and (and (and x6 x0) (or x4 x0)) (or (and x0 x4) (not x5))))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and x2 x0)) +(check-sat) +(push 1) +(assert (and (not (and (or x3 x3) (and x6 x0))) (or (not (or x6 x4)) (or (or x1 x2) (and x4 x6))))) +(assert (and (not (or (and (and (and x4 x2) (not x3)) (or (or x5 x6) (not x2))) (not (or (not x0) (not x4))))) (or (or (not (or (not x0) (or x2 x2))) (and (and (not x5) (not x1)) (or (not x6) (not x5)))) (and (and (not (and x2 x1)) (not (or x6 x0))) (or (not (or x0 x2)) (not (and x1 x2))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (and (not (or (not (not x4)) (or (or x1 x6) (and x2 x4)))) (not (and (and (or x1 x1) (and x1 x6)) (not (not x2)))))) +(assert (not (not x3))) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (and (and (or (or (and (not (and (and (or x9 x6) (or x8 x9)) (not (not x2)))) (and (not (and (and x3 x1) (or x7 x0))) (or (and (or x6 x7) (not x2)) (or (or x8 x8) (not x0))))) (and (or (and (or (or x7 x5) (or x2 x8)) (not (not x3))) (and (and (and x2 x0) (and x1 x9)) (and (and x7 x5) (or x8 x5)))) (and (or (and (or x3 x6) (and x9 x4)) (or (not x8) (and x2 x6))) (not (and (not x7) (or x6 x1)))))) (not (or (or (and (and (and x6 x2) (or x5 x9)) (not (not x2))) (or (or (and x5 x0) (or x3 x0)) (or (or x6 x9) (not x5)))) (or (not (or (not x0) (or x7 x7))) (not (or (and x6 x1) (not x1))))))) (or (and (or (and (not (or (or x4 x2) (and x4 x3))) (or (not (or x1 x7)) (not (not x7)))) (or (or (or (or x3 x0) (and x0 x2)) (and (not x1) (or x3 x8))) (not (or (not x3) (or x3 x0))))) (or (not (or (and (and x3 x7) (not x2)) (or (not x6) (or x8 x9)))) (not (not (or (and x1 x2) (and x6 x3)))))) (and (or (or (not (and (not x3) (not x0))) (and (and (not x4) (and x6 x6)) (and (and x4 x1) (not x3)))) (and (and (or (or x9 x9) (not x5)) (or (and x3 x0) (and x3 x2))) (not (or (not x9) (not x7))))) (or (or (or (or (not x4) (and x0 x2)) (not (or x1 x7))) (and (and (or x1 x8) (and x1 x1)) (and (or x7 x7) (or x0 x1)))) (and (and (not (not x3)) (or (or x2 x0) (not x4))) (and (not (not x8)) (or (and x0 x0) (not x8)))))))) (or (not (or (and (and (not (not (and x1 x2))) (and (not (not x5)) (or (not x9) (and x2 x8)))) (and (or (or (or x7 x1) (not x7)) (not (not x8))) (or (not (and x9 x9)) (or (not x3) (and x0 x0))))) (and (not (not (not (and x6 x6)))) (or (or (and (or x6 x6) (and x0 x9)) (not (not x1))) (or (or (not x2) (or x3 x5)) (or (or x7 x5) (and x1 x0))))))) (not (not (or (or (not (and (and x9 x4) (not x7))) (and (not (and x3 x7)) (and (and x4 x4) (and x1 x0)))) (and (and (and (or x3 x7) (or x5 x7)) (not (not x3))) (not (or (not x7) (or x6 x4)))))))))) +(check-sat) +(push 1) +(assert (not (or (or (and x3 x8) (or x4 x0)) (and (not x9) (and x6 x8))))) +(assert (not (and (and (or (or x9 x5) (and x4 x3)) (not (and x2 x9))) (and (or (and x3 x4) (not x4)) (and (and x0 x3) (or x6 x2)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (or (or (not x4) (and x9 x9)) (or (or x1 x5) (not x4))) (or (and (or x6 x0) (not x3)) (and (or x8 x7) (or x4 x4))))) +(check-sat) +(push 1) +(assert (or (and (and x9 x7) (or x8 x2)) (or (not x9) (or x6 x0)))) +(check-sat) +(pop 1) +(assert (and (not (not (not (and (not (or (not x4) (not x2))) (and (and (and x3 x1) (and x0 x0)) (or (not x2) (not x4))))))) (or (or (not (or (not (not (and x9 x0))) (and (and (not x0) (and x4 x4)) (or (not x0) (not x7))))) (or (or (not (not (and x8 x1))) (or (or (and x1 x3) (and x4 x4)) (or (not x6) (not x7)))) (and (not (and (not x5) (not x1))) (not (and (not x1) (not x2)))))) (or (not (and (and (and (or x0 x8) (not x5)) (not (or x0 x8))) (not (not (not x1))))) (or (not (and (or (and x3 x2) (and x7 x2)) (and (or x6 x8) (not x1)))) (and (and (or (and x0 x6) (and x5 x4)) (and (and x0 x6) (and x1 x0))) (or (or (not x7) (and x2 x3)) (not (or x2 x9))))))))) +(check-sat) +(push 1) +(assert (and (or (and (not (not (and (and x0 x4) (and x6 x4)))) (not (not (and (not x5) (not x9))))) (not (and (or (or (or x0 x1) (or x5 x5)) (not (not x6))) (and (or (and x2 x3) (and x3 x7)) (not (and x3 x3)))))) (or (not (not (or (not (not x8)) (and (not x7) (not x8))))) (not (or (not (not (or x8 x4))) (and (not (or x7 x6)) (not (and x5 x5)))))))) +(assert (not (or (and (and (or (or (or (and (not x4) (not x8)) (not (not x2))) (not (and (not x8) (or x6 x2)))) (not (not (or (and x7 x6) (and x0 x4))))) (or (or (not (not (and x3 x7))) (or (not (not x1)) (not (not x8)))) (and (not (or (not x6) (and x6 x8))) (or (and (not x4) (not x6)) (or (or x3 x1) (and x8 x3)))))) (or (and (not (or (not (and x7 x6)) (and (not x7) (and x5 x7)))) (not (and (not (and x6 x8)) (and (not x8) (not x5))))) (not (and (or (or (or x4 x0) (not x6)) (and (not x3) (not x8))) (not (and (not x1) (and x4 x9))))))) (and (or (and (and (and (and (and x9 x1) (not x9)) (or (or x5 x5) (not x7))) (or (and (not x5) (not x8)) (not (and x0 x1)))) (or (or (or (not x4) (or x1 x6)) (or (or x2 x0) (not x5))) (or (not (not x7)) (not (not x5))))) (or (and (not (or (and x1 x3) (or x1 x7))) (or (or (not x0) (not x6)) (or (not x9) (and x0 x0)))) (and (or (or (or x8 x1) (or x5 x8)) (or (or x1 x7) (and x2 x2))) (not (and (and x5 x9) (and x5 x8)))))) (or (not (and (and (and (or x4 x2) (and x8 x5)) (not (and x2 x2))) (not (not (not x3))))) (and (and (or (or (and x3 x3) (not x2)) (not (or x2 x6))) (or (and (and x9 x1) (not x1)) (not (and x6 x8)))) (not (not (or (not x2) (or x4 x1)))))))))) +(assert (and (not x4) (not x3))) +(assert (and (or x8 x9) (not x1))) +(check-sat) +(pop 2) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(check-sat) +(push 1) +(assert (or (or (and (and (and (not (and (or (not (or x1 x0)) (not (and x4 x3))) (and (or (not x1) (and x1 x5)) (or (and x4 x5) (and x0 x2))))) (and (and (or (and (or x5 x0) (not x2)) (or (not x1) (or x5 x0))) (not (or (or x3 x2) (and x2 x1)))) (and (or (not (not x0)) (and (or x1 x0) (not x4))) (and (not (or x1 x5)) (or (and x0 x2) (or x5 x3)))))) (not (not (or (or (not (not x3)) (or (or x0 x3) (or x4 x5))) (or (not (not x5)) (and (and x3 x1) (or x0 x5))))))) (not (or (and (not (or (not (or x0 x5)) (or (and x1 x0) (and x2 x4)))) (not (not (and (and x0 x0) (and x0 x4))))) (not (and (and (not (and x1 x2)) (or (or x2 x0) (or x3 x4))) (not (or (not x4) (not x2)))))))) (and (and (and (or (not (or (or (or x5 x1) (not x5)) (or (and x2 x0) (not x4)))) (or (or (or (and x4 x3) (not x0)) (not (or x2 x5))) (not (or (or x4 x1) (and x5 x3))))) (not (and (not (not (or x3 x1))) (not (and (and x3 x1) (not x2)))))) (not (or (or (not (and (not x5) (and x2 x5))) (not (and (or x3 x2) (or x4 x2)))) (and (and (and (not x2) (not x4)) (or (and x0 x4) (or x2 x1))) (and (not (or x0 x3)) (and (and x3 x3) (and x4 x5))))))) (or (and (or (and (or (not (or x2 x5)) (not (not x2))) (or (or (not x1) (not x2)) (or (and x5 x5) (not x2)))) (or (and (and (and x3 x2) (and x0 x1)) (not (not x5))) (not (or (and x4 x0) (and x0 x4))))) (not (or (or (not (not x4)) (or (not x3) (or x2 x4))) (not (or (not x0) (and x2 x0)))))) (or (and (or (not (and (and x1 x2) (not x3))) (and (or (not x1) (or x3 x4)) (not (or x4 x0)))) (not (or (and (and x1 x5) (and x0 x1)) (not (or x2 x0))))) (not (or (not (and (or x4 x5) (not x2))) (or (and (or x0 x3) (or x4 x1)) (and (or x5 x0) (not x4))))))))) (not (and (and (or (and (and (or (not (not x4)) (and (and x4 x0) (and x4 x2))) (and (or (or x5 x4) (and x3 x5)) (or (and x2 x4) (and x1 x3)))) (or (not (and (and x2 x5) (and x4 x3))) (or (not (not x3)) (and (and x3 x3) (and x1 x2))))) (or (not (or (not (not x2)) (not (or x3 x1)))) (and (and (or (or x1 x2) (not x2)) (and (or x0 x5) (and x1 x3))) (not (not (and x5 x0)))))) (or (not (or (and (or (and x3 x3) (not x5)) (and (not x4) (and x2 x5))) (not (or (not x3) (or x0 x0))))) (and (and (and (not (and x3 x1)) (not (and x4 x0))) (or (and (not x1) (and x1 x0)) (or (or x5 x3) (and x2 x2)))) (and (not (or (not x2) (and x4 x2))) (not (and (or x3 x5) (or x1 x1))))))) (and (and (or (or (or (not (and x1 x4)) (or (and x1 x1) (and x3 x5))) (or (or (and x4 x4) (or x4 x4)) (and (and x5 x4) (not x1)))) (or (or (not (and x0 x3)) (and (or x3 x2) (or x1 x3))) (and (or (and x0 x2) (or x5 x4)) (not (and x2 x4))))) (or (or (or (not (or x2 x3)) (and (or x2 x3) (or x4 x3))) (and (and (or x1 x2) (and x1 x1)) (not (or x4 x5)))) (and (or (or (and x5 x1) (not x1)) (and (or x3 x5) (not x0))) (and (not (not x5)) (not (and x4 x5)))))) (not (and (and (and (or (and x2 x2) (and x2 x3)) (not (or x3 x0))) (or (not (not x1)) (or (and x4 x2) (not x3)))) (and (or (or (or x4 x3) (or x3 x3)) (not (and x2 x2))) (or (and (and x1 x1) (or x2 x5)) (and (and x2 x3) (not x3))))))))))) +(assert (and (not (not (not (or (and (and (not (and (not x5) (or x1 x1))) (not (or (or x2 x4) (not x0)))) (and (and (and (or x1 x4) (not x3)) (or (and x5 x0) (and x1 x0))) (not (not (not x4))))) (not (not (not (not (not x5))))))))) (not (or (not (and (not (not (not (and (and x0 x3) (or x5 x0))))) (and (and (not (and (and x4 x3) (or x1 x3))) (or (and (and x5 x0) (or x2 x0)) (or (and x4 x2) (and x0 x3)))) (or (or (and (and x3 x4) (or x0 x1)) (or (and x5 x0) (not x1))) (and (not (or x2 x5)) (and (not x1) (and x0 x1))))))) (not (or (not (or (and (or (and x0 x2) (and x5 x3)) (and (and x0 x3) (not x4))) (or (and (not x2) (not x0)) (and (or x2 x1) (not x1))))) (not (not (and (not (not x3)) (or (or x4 x0) (not x1))))))))))) +(check-sat) +(push 1) +(assert (not (not (not (or (or (or x3 x5) (or x2 x0)) (or (or x3 x4) (or x2 x4))))))) +(assert (and (and (or (not x5) (or x0 x3)) (or (and x2 x0) (or x0 x1))) (not (or (not x1) (and x4 x0))))) +(assert (or (not (or x4 x0)) (and (or x1 x3) (and x5 x3)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (or (not (not x1)) (and (or x5 x4) (and x3 x4)))) (not (not (not (and x3 x2)))))) +(assert (not (not (and x2 x4)))) +(check-sat) +(push 1) +(assert (and x3 x3)) +(assert (not (and (not x1) (and x0 x5)))) +(assert (not (and (not (or (and (and (or x2 x1) (not x3)) (and (not x2) (or x1 x1))) (and (and (not x4) (not x5)) (not (not x4))))) (not (or (and (and (not x5) (and x2 x0)) (or (and x3 x5) (or x0 x3))) (not (or (or x2 x4) (not x1)))))))) +(check-sat) +(pop 1) +(assert (not (or (or (or (not x0) (not x5)) (or (and x3 x5) (not x0))) (and (not (and x2 x0)) (and (not x1) (not x1)))))) +(assert (or (not x4) (or x3 x4))) +(assert (not (not (and (and (and x1 x4) (not x4)) (or (or x4 x3) (and x0 x2)))))) +(check-sat) +(pop 1) +(assert (not x1)) +(check-sat) +(pop 1) +(pop 1) +(push 1) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(assert (or (or (not (or (or (not (or (and x4 x4) (not x7))) (not (and (and x5 x7) (not x7)))) (and (and (and (and x6 x6) (not x0)) (not (or x3 x1))) (and (or (not x1) (and x5 x3)) (or (or x7 x6) (not x4)))))) (not (or (or (or (not (or x3 x7)) (not (and x2 x8))) (and (not (not x1)) (or (and x0 x3) (or x2 x5)))) (or (or (or (and x8 x1) (or x3 x0)) (and (not x5) (and x8 x6))) (not (not (and x2 x5))))))) (not (not (and (not (or (or (not x7) (and x8 x2)) (not (or x6 x3)))) (not (and (not (and x8 x3)) (or (not x3) (or x8 x2))))))))) +(check-sat) +(push 1) +(assert (and (and (or (or (and (and (or x1 x5) (not x8)) (and (not x8) (and x0 x8))) (or (or (and x0 x3) (and x0 x6)) (and (or x7 x7) (and x7 x0)))) (or (and (or (and x8 x7) (or x3 x2)) (not (not x7))) (not (and (not x8) (not x5))))) (or (or (and (and (or x2 x6) (or x7 x4)) (and (or x4 x3) (not x5))) (and (or (not x2) (or x2 x7)) (not (and x8 x7)))) (and (and (and (and x5 x4) (not x3)) (not (not x8))) (or (and (or x6 x1) (or x0 x7)) (not (and x8 x4)))))) (and (not (and (or (not (or x5 x5)) (and (and x6 x3) (or x0 x0))) (and (not (or x0 x0)) (and (not x6) (and x8 x6))))) (or (and (not (not (and x3 x8))) (or (not (not x0)) (and (and x5 x6) (or x0 x4)))) (or (and (and (not x2) (not x0)) (and (and x4 x2) (or x1 x6))) (or (and (not x5) (not x8)) (not (and x5 x3)))))))) +(check-sat) +(push 1) +(assert (and (or x7 x5) (and x2 x6))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (not (and x1 x6))) +(assert (or x7 x7)) +(assert (not (or x0 x7))) +(check-sat) +(push 1) +(assert (and (not (or (or (and x6 x2) (or x2 x8)) (or (and x7 x3) (or x2 x5)))) (and (or (not (not x4)) (and (not x4) (not x2))) (not (not (or x1 x7)))))) +(assert (not (and (or (and (and (not (and x6 x1)) (or (and x5 x3) (or x3 x1))) (or (or (not x2) (or x0 x1)) (not (or x7 x5)))) (not (or (not (not x8)) (and (not x4) (and x5 x8))))) (not (or (or (or (or x1 x1) (and x2 x3)) (and (and x5 x8) (not x7))) (and (not (or x5 x8)) (or (not x5) (and x2 x2)))))))) +(assert (not x4)) +(assert (not (and (not (or (not (or (not (or x8 x1)) (or (not x6) (not x4)))) (or (or (and (and x0 x7) (or x2 x7)) (or (or x7 x3) (and x5 x2))) (or (or (and x7 x0) (and x1 x1)) (and (not x7) (or x6 x7)))))) (or (and (and (and (not (not x0)) (and (or x7 x4) (or x3 x6))) (not (not (not x6)))) (or (or (and (and x1 x5) (or x7 x5)) (not (and x2 x3))) (not (or (not x8) (and x1 x8))))) (not (and (not (and (not x8) (and x1 x6))) (or (and (and x0 x0) (not x0)) (not (not x7))))))))) +(assert (or x1 x2)) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (not (and (not x5) (not x7))) (and (or (not x1) (and x4 x1)) (not (and x5 x8)))))) +(assert (not (and (or (and (not (and (and (not (or (not x5) (and x4 x7))) (and (and (and x6 x1) (not x3)) (not (and x5 x1)))) (and (or (or (or x7 x2) (or x2 x6)) (not (not x2))) (and (and (not x6) (and x4 x8)) (and (not x5) (or x1 x6)))))) (or (not (or (not (and (and x3 x5) (or x7 x3))) (or (not (not x7)) (not (not x0))))) (or (not (not (and (or x3 x6) (and x6 x2)))) (or (not (or (or x7 x3) (not x5))) (or (or (and x1 x2) (and x4 x2)) (not (not x7))))))) (and (not (not (or (not (or (not x0) (not x4))) (or (and (and x3 x2) (and x8 x3)) (and (not x1) (not x6)))))) (not (not (or (or (and (or x8 x3) (not x8)) (or (or x7 x5) (or x7 x7))) (and (or (or x4 x4) (or x3 x3)) (and (not x8) (not x7)))))))) (and (not (or (not (or (or (not (and x4 x4)) (or (and x5 x8) (or x5 x4))) (not (not (and x6 x3))))) (not (or (or (or (not x3) (or x5 x2)) (not (not x0))) (and (or (or x6 x4) (and x0 x3)) (and (not x2) (not x0))))))) (and (not (not (or (or (or (or x6 x6) (and x6 x8)) (or (or x1 x5) (or x8 x4))) (and (and (not x6) (or x8 x0)) (not (or x0 x5)))))) (or (not (not (or (or (not x0) (and x3 x4)) (or (and x3 x3) (not x2))))) (and (or (or (or (not x1) (not x0)) (not (or x0 x2))) (and (and (and x8 x7) (and x8 x2)) (or (or x7 x4) (and x1 x3)))) (or (or (or (or x8 x1) (or x8 x6)) (not (not x6))) (or (or (and x8 x7) (or x4 x6)) (and (not x3) (and x0 x0))))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (and x7 x2) (or x4 x6)))) +(check-sat) +(push 1) +(pop 2) +(pop 1) diff --git a/test/regress/regress1/push-pop/fuzz_20.smt2 b/test/regress/regress1/push-pop/fuzz_20.smt2 new file mode 100644 index 000000000..b37d6c035 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_20.smt2 @@ -0,0 +1,52 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (and x7 x7))) +(check-sat) +(push 1) +(assert (or (or x0 x1) (not x7))) +(assert (not (and x6 x9))) +(assert (and (and (not (or x7 x5)) (or (or x3 x8) (or x5 x8))) (or (or (or x1 x5) (and x3 x6)) (or (and x2 x5) (or x1 x1))))) +(assert (or (not (or (not (not (not x9))) (and (or (and x2 x6) (and x2 x4)) (not (or x8 x2))))) (not (or (and (and (not x2) (not x3)) (and (or x0 x0) (and x7 x5))) (not (not (or x1 x9))))))) +(assert (or (or (not (or (and (not (and (or (or x6 x6) (and x0 x2)) (or (not x5) (not x3)))) (not (and (or (and x1 x2) (not x1)) (not (not x3))))) (or (not (not (or (or x9 x0) (not x6)))) (and (or (and (and x2 x6) (not x4)) (not (not x9))) (not (or (not x7) (or x4 x9))))))) (and (not (and (and (or (or (and x1 x2) (and x1 x5)) (and (not x7) (or x5 x1))) (or (not (and x0 x1)) (or (not x6) (not x1)))) (and (or (not (not x3)) (or (not x1) (not x2))) (or (and (and x4 x6) (not x4)) (and (or x1 x6) (or x2 x3)))))) (and (and (and (or (not (or x9 x9)) (not (or x7 x3))) (or (not (and x5 x3)) (not (not x8)))) (not (or (or (not x1) (or x4 x9)) (not (and x4 x0))))) (or (or (and (or (or x0 x7) (or x4 x4)) (or (or x5 x4) (and x0 x4))) (or (not (and x7 x3)) (or (and x8 x0) (or x7 x8)))) (not (not (and (not x9) (and x1 x9)))))))) (not (and (or (not (not (and (and (and x4 x1) (or x5 x1)) (and (or x5 x4) (not x5))))) (not (not (and (or (and x3 x7) (or x2 x7)) (or (or x5 x0) (or x7 x4)))))) (not (not (not (not (or (or x3 x0) (or x7 x7)))))))))) +(check-sat) +(pop 1) +(assert (or (not (or (and (or (not (and (or x8 x0) (and x5 x2))) (not (not (or x6 x0)))) (not (and (or (or x6 x9) (and x5 x7)) (and (or x1 x7) (and x0 x0))))) (or (and (and (not (not x1)) (not (and x8 x5))) (and (and (and x5 x2) (and x7 x1)) (not (and x0 x0)))) (or (not (and (and x3 x5) (not x3))) (not (or (and x1 x0) (and x2 x4))))))) (not (and (and (and (not (or (not x4) (or x3 x7))) (not (not (not x3)))) (or (not (not (and x2 x1))) (and (or (not x6) (and x0 x8)) (not (not x3))))) (or (or (not (and (or x2 x5) (and x9 x8))) (or (or (and x2 x6) (not x3)) (not (and x7 x3)))) (or (or (not (or x6 x4)) (not (not x0))) (or (or (not x3) (or x6 x7)) (not (and x6 x7))))))))) +(check-sat) +(push 1) +(assert (or (and (or (and (or (or (and (not x5) (not x9)) (or (and x3 x6) (and x3 x4))) (not (or (not x5) (or x6 x4)))) (and (and (and (not x4) (not x1)) (not (and x6 x2))) (and (or (not x4) (not x8)) (or (and x1 x3) (not x6))))) (not (not (and (or (not x8) (and x9 x1)) (and (not x3) (or x9 x4)))))) (not (and (or (not (or (or x1 x8) (or x9 x5))) (not (not (or x8 x8)))) (and (not (not (and x2 x5))) (or (or (not x6) (or x1 x2)) (or (not x0) (and x8 x4))))))) (and (or (or (and (and (not (and x7 x8)) (or (or x8 x3) (or x5 x2))) (not (or (and x3 x0) (and x8 x1)))) (or (and (and (not x2) (and x2 x2)) (or (not x1) (and x6 x6))) (or (and (not x2) (or x6 x9)) (not (and x8 x3))))) (not (and (or (or (or x7 x1) (not x6)) (and (and x6 x5) (not x8))) (not (not (not x4)))))) (and (not (not (or (or (or x6 x5) (not x6)) (or (or x7 x8) (or x2 x2))))) (not (or (and (or (and x1 x3) (not x7)) (and (and x4 x9) (or x2 x2))) (or (not (or x9 x7)) (not (and x5 x2))))))))) +(assert (and (not (and (and (or x2 x3) (or x1 x6)) (and (and x3 x6) (or x0 x7)))) (not (or (or (or x4 x0) (and x3 x4)) (and (not x6) (or x5 x8)))))) +(check-sat) +(push 1) +(assert (not (and (and (and x4 x6) (or x9 x4)) (or (and x1 x9) (not x1))))) +(check-sat) +(push 1) +(assert (or (not (and (or (and (not x2) (not x5)) (not (and x0 x5))) (not (and (and x2 x9) (and x2 x3))))) (not (not (and (not (or x7 x9)) (and (and x7 x4) (or x8 x3))))))) +(check-sat) +(pop 1) +(assert (not (or x0 x0))) +(assert (not (not (or (or (and (and (not (or (and (not x0) (not x1)) (and (and x4 x9) (and x3 x9)))) (not (or (not (or x9 x3)) (and (and x4 x2) (not x7))))) (and (not (and (or (not x1) (and x9 x5)) (not (or x9 x3)))) (and (or (and (or x6 x1) (or x6 x6)) (or (not x0) (not x0))) (or (and (not x3) (and x5 x7)) (not (and x9 x7)))))) (not (not (or (not (or (and x1 x0) (not x5))) (or (and (or x5 x5) (and x5 x7)) (and (and x1 x7) (and x4 x6))))))) (and (not (not (or (or (or (or x9 x0) (or x7 x3)) (or (not x0) (or x8 x0))) (and (or (and x3 x1) (or x4 x7)) (and (not x5) (and x0 x1)))))) (or (or (and (and (or (not x0) (not x2)) (not (and x3 x9))) (or (and (or x9 x6) (or x6 x0)) (or (not x6) (or x8 x0)))) (not (or (and (and x8 x6) (not x1)) (and (not x4) (or x5 x3))))) (or (or (or (or (and x2 x7) (and x5 x4)) (and (or x7 x5) (or x7 x8))) (and (not (and x7 x0)) (and (not x2) (not x0)))) (and (and (or (and x9 x6) (or x5 x9)) (not (or x8 x3))) (or (and (or x8 x4) (and x5 x2)) (or (or x5 x1) (and x5 x8))))))))))) +(assert (and (or (and (or (and (not (and x3 x6)) (or (and x1 x3) (not x2))) (and (not (not x7)) (and (not x1) (not x5)))) (not (not (not (or x6 x5))))) (or (and (or (not (and x2 x0)) (and (or x6 x8) (and x9 x2))) (or (not (and x7 x3)) (and (not x3) (or x7 x0)))) (not (or (not (not x2)) (or (or x3 x7) (not x9)))))) (and (not (or (and (not (or x9 x3)) (or (not x6) (and x1 x2))) (and (or (or x2 x3) (and x6 x7)) (and (and x2 x8) (and x5 x7))))) (not (or (not (and (not x0) (and x8 x1))) (not (not (or x7 x2)))))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_23.smt2 b/test/regress/regress1/push-pop/fuzz_23.smt2 new file mode 100644 index 000000000..22ed7dfa5 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_23.smt2 @@ -0,0 +1,41 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(check-sat) +(push 1) +(assert (or x1 x3)) +(assert (or (or x5 x0) (not x0))) +(check-sat) +(push 1) +(assert (and (not (or (or (not (or (or (or (and (not x2) (not x0)) (or (and x1 x0) (not x3))) (not (or (and x2 x8) (and x6 x6)))) (or (not (not (not x4))) (and (or (and x1 x1) (not x1)) (or (not x1) (not x6)))))) (not (or (and (or (and (not x4) (and x0 x6)) (and (not x1) (or x8 x1))) (not (not (not x0)))) (not (and (not (not x4)) (and (not x3) (and x2 x0))))))) (or (and (or (and (not (or (not x7) (and x1 x2))) (and (not (not x1)) (and (not x1) (or x3 x2)))) (or (or (and (and x2 x0) (or x3 x2)) (and (and x0 x1) (or x0 x5))) (not (and (and x3 x8) (not x4))))) (and (and (not (and (and x1 x5) (or x1 x6))) (and (or (or x4 x7) (and x4 x3)) (or (or x2 x0) (or x5 x1)))) (or (or (not (not x1)) (or (and x6 x1) (or x4 x2))) (not (and (and x0 x8) (and x7 x1)))))) (and (or (or (and (and (and x6 x8) (and x3 x7)) (and (and x7 x0) (or x5 x6))) (and (or (or x5 x6) (and x8 x7)) (and (and x0 x6) (and x1 x1)))) (and (not (or (not x1) (or x1 x2))) (and (and (or x2 x8) (not x5)) (not (or x0 x3))))) (or (and (and (not (not x3)) (not (or x1 x6))) (and (not (not x8)) (or (and x0 x6) (or x0 x8)))) (not (and (or (not x3) (or x4 x3)) (and (not x7) (not x7))))))))) (and (or (not (or (and (or (or (not (or x2 x2)) (not (and x0 x8))) (or (or (not x8) (not x8)) (and (not x0) (and x1 x4)))) (and (or (not (or x4 x0)) (not (or x1 x6))) (and (and (and x4 x7) (or x3 x5)) (and (or x6 x6) (and x0 x3))))) (or (or (or (and (not x6) (and x2 x6)) (and (not x6) (or x5 x5))) (and (or (or x2 x8) (not x1)) (or (or x8 x4) (or x3 x5)))) (and (or (or (and x7 x8) (not x2)) (or (and x8 x2) (and x3 x2))) (or (or (and x2 x5) (and x1 x8)) (or (not x8) (not x5))))))) (not (not (and (and (or (not (and x8 x0)) (or (not x0) (not x8))) (or (and (and x3 x7) (not x8)) (and (and x4 x7) (and x8 x0)))) (or (and (or (and x1 x5) (not x2)) (not (and x8 x5))) (and (and (and x1 x8) (not x2)) (and (not x7) (or x5 x6)))))))) (not (and (and (or (or (not (and (not x6) (not x7))) (or (or (and x3 x7) (and x7 x0)) (not (not x8)))) (not (and (not (or x4 x6)) (and (not x1) (and x4 x3))))) (not (not (and (or (not x8) (and x5 x8)) (and (or x0 x5) (and x7 x3)))))) (not (and (not (and (not (and x6 x8)) (or (not x7) (and x3 x0)))) (or (not (not (and x8 x0))) (or (or (not x0) (not x6)) (or (not x8) (or x0 x7))))))))))) +(check-sat) +(push 1) +(assert (or (or x5 x6) (not x3))) +(assert (or (and (not (and (not (or (not (or x1 x5)) (or (and x2 x4) (and x1 x1)))) (and (or (and (or x5 x1) (and x2 x6)) (not (or x7 x6))) (or (not (and x7 x3)) (or (and x3 x7) (or x8 x4)))))) (and (or (and (or (not (not x6)) (or (and x6 x0) (not x7))) (or (not (not x0)) (or (not x8) (or x5 x6)))) (and (or (not (or x5 x2)) (not (or x8 x6))) (and (not (or x5 x2)) (and (and x7 x1) (and x3 x1))))) (and (not (not (or (or x8 x4) (not x3)))) (not (not (or (or x8 x2) (and x0 x8))))))) (and (not (or (and (not (not (not x4))) (or (or (or x5 x3) (not x1)) (not (not x2)))) (not (or (and (not x7) (not x5)) (and (and x5 x5) (not x3)))))) (and (not (or (or (not (not x3)) (or (and x4 x7) (and x7 x1))) (not (and (and x2 x1) (not x1))))) (and (and (or (and (not x0) (and x6 x2)) (and (and x8 x2) (not x5))) (not (not (or x6 x2)))) (not (not (and (and x2 x7) (not x2))))))))) +(check-sat) +(push 1) +(assert (or (or (not x6) (or x4 x3)) (or (or x8 x6) (not x4)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (or (or (and (or (and (not (not (and (and x6 x0) (not x1)))) (not (or (and (and x4 x3) (and x1 x0)) (not (not x7))))) (and (not (not (and (and x3 x7) (or x5 x8)))) (and (not (and (or x4 x0) (or x1 x8))) (or (and (and x8 x6) (and x4 x7)) (not (or x1 x4)))))) (not (not (or (and (or (and x6 x0) (and x6 x3)) (or (not x3) (not x6))) (not (or (or x3 x5) (not x2))))))) (or (and (and (and (and (not (and x2 x4)) (or (not x3) (and x1 x8))) (or (or (not x6) (and x2 x7)) (and (and x0 x2) (not x1)))) (or (and (or (or x5 x6) (or x3 x3)) (not (or x7 x2))) (not (or (or x0 x8) (or x7 x2))))) (and (or (not (and (and x0 x8) (and x2 x1))) (not (and (not x7) (and x8 x1)))) (and (not (and (not x8) (or x2 x8))) (and (or (not x3) (not x7)) (not (not x7)))))) (or (and (not (or (or (not x7) (or x4 x7)) (and (not x7) (or x2 x7)))) (and (and (or (not x4) (or x6 x3)) (not (and x2 x4))) (and (not (or x1 x6)) (or (not x3) (or x1 x1))))) (not (or (not (not (not x5))) (not (or (or x4 x1) (not x0)))))))) (not (and (or (not (not (or (and (and x8 x7) (and x3 x5)) (or (and x1 x3) (or x0 x1))))) (not (not (or (or (not x0) (and x7 x8)) (not (not x2)))))) (or (or (not (or (or (or x8 x6) (or x4 x0)) (or (and x2 x7) (and x8 x8)))) (not (or (not (or x1 x2)) (not (not x7))))) (not (not (and (not (or x7 x4)) (and (not x0) (and x2 x1))))))))) (not (or (and (and (or (and (and (and (or x7 x1) (or x5 x2)) (or (not x8) (not x1))) (not (or (and x5 x4) (not x4)))) (and (or (or (and x7 x2) (not x4)) (not (or x8 x6))) (and (or (not x3) (and x7 x3)) (not (or x2 x4))))) (or (not (not (and (or x4 x7) (and x1 x5)))) (not (not (and (not x5) (not x2)))))) (not (not (not (and (not (not x7)) (not (and x1 x7))))))) (or (and (or (or (and (or (not x7) (not x6)) (or (or x2 x3) (or x2 x7))) (not (and (or x8 x8) (and x1 x8)))) (and (not (and (not x7) (not x6))) (or (and (and x5 x4) (or x1 x7)) (and (and x2 x1) (not x6))))) (or (or (or (or (and x3 x8) (not x4)) (and (or x2 x6) (and x0 x0))) (and (and (and x1 x3) (or x4 x2)) (not (or x4 x8)))) (or (and (not (or x8 x8)) (and (or x0 x3) (or x3 x0))) (and (not (and x5 x3)) (and (not x0) (and x3 x1)))))) (not (and (and (and (or (or x0 x3) (and x3 x7)) (and (or x3 x1) (and x4 x8))) (and (not (and x7 x6)) (or (not x0) (not x0)))) (and (or (and (or x0 x3) (not x0)) (or (or x1 x2) (or x8 x3))) (and (or (not x0) (or x2 x4)) (not (or x1 x1))))))))))) +(check-sat) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_24.smt2 b/test/regress/regress1/push-pop/fuzz_24.smt2 new file mode 100644 index 000000000..edff03a9d --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_24.smt2 @@ -0,0 +1,42 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (or x1 x1) (not x4))) +(assert (not (and (or (not (or (and (and x2 x0) (and x1 x4)) (and (or x4 x1) (and x2 x6)))) (and (or (not (and x4 x2)) (or (and x4 x3) (not x3))) (or (or (not x0) (or x2 x2)) (not (or x5 x6))))) (not (not (not (or (or x5 x6) (or x0 x3)))))))) +(check-sat) +(push 1) +(assert (not (not (or (not x4) (not x6))))) +(assert (not (and (not (or (and (and (or (not (or x3 x4)) (or (and x0 x3) (or x3 x3))) (and (or (and x2 x1) (or x2 x4)) (and (not x2) (or x6 x2)))) (not (not (and (or x0 x1) (and x6 x4))))) (and (or (and (and (not x3) (not x2)) (or (or x3 x0) (and x4 x0))) (and (and (and x5 x0) (not x6)) (not (not x0)))) (or (and (not (and x2 x4)) (not (or x0 x2))) (not (not (and x6 x3))))))) (and (or (or (or (or (not (or x4 x1)) (not (and x6 x4))) (and (and (or x3 x0) (and x3 x2)) (or (or x6 x6) (and x5 x5)))) (not (not (and (and x6 x3) (or x2 x2))))) (or (or (and (not (not x3)) (or (and x5 x4) (or x3 x1))) (and (or (not x6) (or x6 x2)) (or (not x4) (or x4 x6)))) (or (and (not (and x0 x2)) (not (not x0))) (not (or (or x5 x1) (and x0 x4)))))) (and (or (and (or (not (and x0 x6)) (not (and x1 x5))) (or (or (or x2 x4) (or x1 x6)) (or (not x4) (or x3 x4)))) (and (or (not (or x6 x0)) (and (and x2 x0) (or x0 x4))) (not (or (not x3) (or x4 x0))))) (or (not (not (or (and x6 x5) (and x6 x6)))) (and (not (or (or x4 x5) (or x3 x0))) (not (and (not x2) (not x5)))))))))) +(assert (or (not (not (and (not (and (and (not (or x1 x2)) (and (not x6) (or x3 x5))) (and (not (or x0 x2)) (not (or x4 x1))))) (or (or (not (not (and x4 x6))) (or (and (or x6 x4) (or x2 x3)) (or (and x6 x6) (not x3)))) (not (and (and (or x1 x3) (or x3 x0)) (or (not x2) (not x4)))))))) (not (or (not (and (not (or (or (not x6) (and x0 x1)) (and (or x5 x0) (and x0 x6)))) (not (not (and (and x5 x6) (and x4 x5)))))) (not (and (not (or (and (not x6) (or x1 x5)) (or (or x5 x6) (and x3 x6)))) (and (not (not (or x1 x4))) (and (or (or x4 x6) (or x2 x2)) (not (or x2 x6)))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (or (not (or (or (and (not (not (or x4 x6))) (not (not (or x6 x1)))) (or (not (or (and x6 x5) (or x4 x1))) (or (or (or x3 x4) (not x4)) (not (not x3))))) (or (or (and (or (and x3 x0) (and x2 x1)) (or (not x4) (or x4 x1))) (and (and (or x1 x2) (and x6 x6)) (not (or x3 x5)))) (or (and (and (and x5 x5) (not x3)) (not (or x0 x0))) (or (or (or x4 x2) (or x5 x1)) (and (or x1 x2) (not x0))))))) (or (and (not (not (and (or (and x6 x2) (and x2 x4)) (or (and x2 x1) (and x1 x1))))) (and (or (or (and (or x3 x0) (or x4 x2)) (or (or x0 x2) (and x0 x0))) (and (not (and x4 x6)) (not (and x5 x6)))) (and (and (and (not x1) (not x6)) (and (not x0) (and x1 x0))) (and (not (or x4 x6)) (or (or x0 x5) (not x0)))))) (or (and (not (or (not (and x1 x5)) (not (not x5)))) (or (or (and (and x6 x3) (and x0 x1)) (not (or x5 x1))) (and (and (or x6 x1) (not x4)) (and (or x1 x5) (or x4 x6))))) (and (not (or (and (not x4) (and x4 x3)) (or (not x1) (not x1)))) (or (or (and (and x3 x1) (and x4 x5)) (not (and x5 x0))) (and (not (not x3)) (or (and x5 x6) (and x3 x5)))))))) (or (and (not (or (and (not (not (and x5 x6))) (or (and (not x1) (not x4)) (or (and x0 x5) (not x1)))) (not (or (and (and x1 x3) (or x2 x1)) (and (or x6 x2) (not x5)))))) (not (and (and (or (and (not x3) (not x5)) (or (or x1 x3) (or x1 x2))) (and (or (and x4 x4) (not x1)) (and (or x6 x0) (not x1)))) (and (and (or (or x1 x2) (and x2 x3)) (and (not x6) (and x2 x2))) (or (not (or x4 x6)) (not (or x1 x3))))))) (and (or (not (or (not (not (not x3))) (or (not (not x0)) (not (and x2 x1))))) (or (not (or (not (not x3)) (not (not x6)))) (or (and (not (and x5 x3)) (not (or x3 x2))) (or (and (or x0 x2) (and x1 x2)) (or (not x2) (not x6)))))) (not (not (not (and (and (and x0 x0) (not x3)) (and (and x6 x4) (and x1 x5)))))))))) +(check-sat) +(push 1) +(assert (not (not (and x3 x3)))) +(check-sat) +(pop 1) +(assert (not (or x4 x2))) +(assert (and (not (and x3 x3)) (or (not x2) (or x4 x2)))) +(assert (and (or x0 x1) (or x2 x5))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_25.smt2 b/test/regress/regress1/push-pop/fuzz_25.smt2 new file mode 100644 index 000000000..8ec42e5fc --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_25.smt2 @@ -0,0 +1,79 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (and (and (and (and (not (or (or x2 x3) (and x5 x1))) (or (or (and x5 x2) (or x6 x0)) (not (and x3 x5)))) (and (and (and (and x2 x4) (and x4 x5)) (or (not x6) (and x6 x6))) (or (and (not x6) (and x0 x6)) (not (not x0))))) (or (or (and (and (not x3) (not x4)) (or (and x4 x6) (or x1 x5))) (and (or (not x2) (and x1 x3)) (or (and x2 x4) (or x6 x4)))) (and (or (not (not x0)) (or (and x1 x3) (or x3 x4))) (or (and (not x2) (not x3)) (or (and x6 x3) (or x0 x2)))))) (or (and (not (or (and (and x1 x5) (and x3 x3)) (not (and x4 x5)))) (or (and (or (or x3 x1) (or x2 x5)) (and (or x4 x6) (not x2))) (not (not (and x1 x1))))) (or (or (or (not (not x4)) (or (and x6 x5) (not x0))) (not (or (and x0 x0) (and x1 x3)))) (or (not (and (or x0 x0) (or x1 x1))) (or (not (and x5 x4)) (and (and x6 x6) (or x5 x5)))))))) (or (and (not (or (or (and (not (and x6 x2)) (or (not x1) (and x5 x6))) (and (or (and x5 x1) (and x2 x3)) (not (not x2)))) (not (or (or (and x1 x0) (and x6 x4)) (or (and x5 x5) (not x5)))))) (not (and (or (not (and (and x5 x3) (and x6 x3))) (or (not (not x2)) (and (and x6 x5) (and x0 x6)))) (not (and (not (or x3 x6)) (or (not x4) (or x0 x4))))))) (not (not (and (not (and (or (or x0 x1) (not x6)) (or (and x4 x0) (and x1 x6)))) (and (not (and (or x2 x0) (not x2))) (not (or (not x3) (or x0 x6)))))))))) +(assert (and (and (not (not x1)) (not (or x2 x0))) (and (and (not x4) (and x3 x3)) (or (not x4) (and x6 x4))))) +(assert (or (or (or (or (and x6 x0) (not x6)) (and (or x5 x0) (or x0 x6))) (not (not (or x0 x0)))) (or (or (or (not x3) (not x1)) (and (not x2) (and x5 x4))) (not (and (not x5) (not x6)))))) +(assert (and (or (and (not (and x0 x2)) (or (not x0) (or x6 x2))) (or (not (and x2 x0)) (and (not x5) (not x4)))) (not (and (or (or x2 x5) (not x2)) (not (and x0 x1)))))) +(assert (and (or (and x4 x5) (and x4 x4)) (or (not x4) (or x4 x0)))) +(assert (and x2 x6)) +(assert (or (or (and (or x5 x6) (or x6 x4)) (or (not x2) (and x3 x0))) (not (or (and x1 x6) (not x2))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (not (and (and (not (or (or x2 x3) (and x1 x6))) (and (and (and x2 x1) (and x2 x4)) (not (or x2 x1)))) (or (not (not (or x4 x6))) (or (or (or x1 x6) (or x4 x4)) (or (or x5 x4) (and x4 x5)))))) (or (and (not (not (or (and x0 x2) (and x6 x6)))) (and (and (or (or x3 x2) (and x4 x2)) (or (not x6) (not x2))) (not (not (not x4))))) (and (or (and (not (or x1 x6)) (or (and x6 x0) (or x6 x1))) (and (and (and x0 x0) (not x3)) (or (not x2) (not x5)))) (or (not (not (or x6 x2))) (or (or (and x5 x6) (or x1 x3)) (or (and x4 x2) (and x1 x0))))))) (not (or (or (not (and (and (and x0 x6) (and x0 x1)) (and (or x0 x3) (or x3 x5)))) (not (or (not (not x3)) (not (or x0 x3))))) (and (and (and (and (and x0 x0) (not x0)) (not (and x4 x6))) (or (or (not x2) (not x2)) (or (not x5) (not x0)))) (or (or (or (and x5 x2) (or x5 x0)) (and (and x2 x0) (not x0))) (not (not (or x2 x4))))))))) +(check-sat) +(push 1) +(assert (and (and (or (and (or (or (not x2) (or x6 x4)) (not (not x4))) (or (not (or x3 x0)) (or (and x5 x6) (or x3 x2)))) (and (not (and (or x1 x5) (and x5 x6))) (or (and (or x2 x4) (or x4 x2)) (or (or x6 x6) (and x2 x6))))) (not (not (or (or (not x4) (and x5 x3)) (and (not x2) (and x4 x0)))))) (not (and (not (and (and (not x6) (not x2)) (not (or x6 x5)))) (not (or (not (and x2 x5)) (not (not x0)))))))) +(assert (not x2)) +(assert (and (not (and (and (and (or (not (or (not x3) (not x0))) (and (or (and x4 x0) (not x0)) (not (not x3)))) (not (not (or (and x2 x4) (and x0 x0))))) (not (or (and (or (not x4) (and x5 x1)) (or (or x1 x2) (and x4 x0))) (and (not (and x1 x5)) (and (and x5 x4) (or x1 x6)))))) (and (or (or (or (and (not x3) (and x0 x3)) (and (not x4) (not x1))) (not (or (or x0 x0) (or x0 x1)))) (or (and (and (and x3 x0) (or x2 x6)) (and (or x4 x5) (not x0))) (not (or (or x6 x3) (not x0))))) (not (and (and (and (or x6 x5) (not x0)) (and (and x1 x6) (not x1))) (and (or (or x2 x5) (or x5 x6)) (not (not x0)))))))) (or (or (and (not (and (or (not (or x4 x2)) (and (and x5 x2) (or x6 x1))) (or (not (and x2 x5)) (not (not x2))))) (and (and (or (or (and x6 x0) (not x5)) (or (and x3 x3) (not x1))) (and (and (not x2) (not x2)) (and (or x0 x3) (not x0)))) (and (not (and (or x6 x2) (and x5 x1))) (not (not (and x1 x4)))))) (or (or (and (or (and (not x3) (or x4 x1)) (and (or x2 x6) (and x2 x6))) (or (and (or x0 x1) (not x6)) (or (and x2 x3) (or x3 x0)))) (or (and (or (and x2 x3) (not x6)) (not (and x3 x2))) (and (or (not x3) (and x1 x3)) (and (not x2) (and x1 x6))))) (or (and (not (and (and x2 x4) (not x1))) (or (or (and x2 x2) (and x1 x5)) (not (not x5)))) (and (or (and (not x5) (or x2 x0)) (and (and x0 x6) (or x2 x3))) (and (and (and x0 x4) (and x3 x1)) (not (and x3 x2))))))) (or (or (not (not (not (or (or x6 x2) (or x1 x0))))) (not (and (not (not (not x1))) (not (and (or x1 x6) (and x3 x2)))))) (and (or (and (not (or (and x6 x0) (and x4 x3))) (and (not (not x2)) (or (not x1) (not x2)))) (or (not (or (not x2) (and x3 x6))) (or (or (not x3) (and x4 x1)) (not (and x5 x3))))) (not (or (and (and (or x6 x6) (and x1 x0)) (and (and x0 x6) (not x0))) (not (and (and x5 x1) (not x4)))))))))) +(assert (and (and (and (or (and (and (or (not x6) (and x5 x4)) (or (and x5 x4) (or x0 x2))) (and (and (and x6 x3) (not x4)) (and (not x2) (or x3 x1)))) (and (not (or (or x4 x4) (or x2 x4))) (or (or (and x2 x2) (or x2 x1)) (or (not x1) (and x5 x4))))) (or (and (not (or (not x5) (not x2))) (not (and (not x2) (and x4 x6)))) (or (not (and (and x2 x1) (or x3 x1))) (and (not (not x2)) (and (and x4 x5) (not x3)))))) (or (not (not (not (not (not x5))))) (and (not (or (or (or x4 x3) (and x0 x6)) (and (or x2 x2) (and x6 x1)))) (or (not (not (not x3))) (not (or (or x0 x1) (not x3))))))) (or (or (or (not (and (not (or x4 x6)) (not (not x3)))) (or (not (and (not x3) (or x2 x2))) (or (not (and x4 x0)) (or (or x5 x6) (not x1))))) (and (or (or (and (not x2) (and x0 x2)) (or (not x5) (not x5))) (and (and (and x4 x5) (and x5 x3)) (or (not x3) (or x5 x1)))) (not (not (not (or x1 x6)))))) (and (or (or (or (or (and x2 x4) (or x4 x2)) (and (not x1) (or x5 x3))) (or (and (or x5 x2) (and x1 x1)) (and (not x1) (and x5 x6)))) (and (not (or (and x1 x3) (or x5 x3))) (and (and (not x2) (not x2)) (and (and x5 x5) (and x1 x6))))) (or (or (and (and (not x0) (or x3 x6)) (not (and x5 x4))) (and (or (not x3) (or x3 x6)) (not (and x4 x6)))) (not (and (not (or x5 x3)) (and (not x3) (or x2 x1))))))))) +(check-sat) +(pop 1) +(assert (or (not (or (not (and (or (or (and x3 x5) (not x5)) (and (and x5 x2) (not x0))) (not (not (or x6 x5))))) (or (or (not (not (and x0 x6))) (and (not (not x6)) (or (and x6 x5) (or x0 x3)))) (or (and (not (not x4)) (and (and x2 x3) (and x4 x2))) (and (or (or x3 x5) (not x1)) (and (or x5 x2) (or x6 x4))))))) (and (not (and (or (or (and (and x6 x0) (and x1 x2)) (and (and x0 x3) (or x6 x4))) (and (not (or x4 x1)) (and (and x0 x4) (not x4)))) (or (or (and (not x0) (and x4 x1)) (not (or x0 x0))) (and (and (not x5) (and x1 x3)) (not (and x3 x2)))))) (not (not (not (and (not (and x0 x0)) (not (not x0))))))))) +(assert (and (or (or (and x3 x2) (and x1 x6)) (or (or x6 x3) (not x0))) (or (not (and x5 x5)) (or (not x1) (or x3 x6))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (or (not (not (and (and (not (and x2 x5)) (and (or x1 x2) (not x1))) (not (or (or x0 x2) (not x6)))))) (not (or (or (and (or (not x1) (not x6)) (and (not x3) (or x6 x0))) (and (not (or x4 x1)) (or (or x1 x6) (or x1 x2)))) (and (not (not (not x0))) (or (not (and x2 x6)) (not (and x5 x3))))))) (not (and (and (or (not (and (or x5 x4) (and x1 x1))) (and (or (or x1 x1) (not x3)) (and (and x3 x6) (and x6 x1)))) (and (or (or (or x5 x4) (not x2)) (or (not x2) (or x2 x4))) (not (and (not x6) (not x5))))) (and (and (not (or (and x0 x3) (and x3 x2))) (or (not (not x6)) (not (not x4)))) (or (and (and (not x3) (not x1)) (and (and x2 x4) (not x3))) (not (and (and x1 x1) (or x0 x4))))))))) +(assert (not (not (not (or (or (or (not x4) (or x1 x4)) (or (and x2 x3) (or x4 x5))) (and (not (not x5)) (and (and x0 x6) (and x5 x1)))))))) +(check-sat) +(pop 1) +(assert (and (and x2 x0) (not x4))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (or (or (or (not (or (and (and x5 x5) (not x5)) (or (or x1 x2) (not x1)))) (not (and (and (and x6 x5) (or x6 x5)) (and (or x6 x0) (and x6 x4))))) (and (or (or (or (not x3) (or x0 x1)) (or (or x0 x4) (or x6 x4))) (and (and (and x3 x4) (and x0 x0)) (or (and x6 x3) (or x3 x0)))) (not (or (and (or x1 x1) (or x1 x0)) (and (or x0 x3) (and x0 x5)))))) (or (or (and (and (not (not x5)) (and (or x4 x0) (or x3 x2))) (and (and (or x1 x2) (and x0 x2)) (and (and x4 x6) (and x0 x4)))) (or (not (and (and x5 x2) (or x1 x5))) (not (not (not x2))))) (or (not (or (not (and x3 x5)) (and (not x3) (and x2 x3)))) (and (or (and (and x2 x0) (or x6 x4)) (or (or x0 x2) (or x3 x3))) (or (or (not x1) (and x2 x4)) (not (and x2 x6))))))) (and (not (or (or (and (and (and x4 x4) (not x2)) (or (or x3 x2) (not x5))) (and (not (or x5 x2)) (not (or x2 x5)))) (or (not (not (or x3 x0))) (and (not (not x5)) (and (or x0 x1) (or x2 x5)))))) (and (not (and (or (and (and x5 x6) (not x0)) (and (or x0 x1) (and x4 x5))) (not (and (and x4 x0) (or x0 x4))))) (or (not (and (not (or x2 x5)) (or (not x0) (not x0)))) (or (and (or (or x3 x6) (not x2)) (and (not x5) (and x0 x2))) (not (or (or x6 x3) (not x6))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (or (or x4 x3) (and x5 x3)) (and (and x3 x2) (not x1)))) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_26.smt2 b/test/regress/regress1/push-pop/fuzz_26.smt2 new file mode 100644 index 000000000..d4fd2c710 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_26.smt2 @@ -0,0 +1,49 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or x4 x2) (or x4 x2))) +(assert (not (not (or (not (or (and x3 x5) (not x6))) (or (or (or x1 x5) (or x0 x3)) (not (or x3 x6))))))) +(assert (or (and (and (or (and x1 x6) (or x2 x4)) (and (and x1 x0) (or x1 x4))) (and (not (and x3 x6)) (not (not x0)))) (and (not (not (and x4 x0))) (not (or (not x6) (and x6 x5)))))) +(assert (or (and (and (and (or (not (and (or (or (not x4) (not x3)) (not (and x3 x3))) (and (not (not x3)) (not (and x0 x2))))) (and (and (not (and (and x1 x0) (or x2 x2))) (or (or (or x3 x4) (not x0)) (not (not x5)))) (or (not (and (not x3) (or x4 x4))) (or (not (and x0 x2)) (not (or x3 x0)))))) (or (or (or (not (and (and x0 x6) (not x3))) (or (not (not x3)) (and (not x3) (or x5 x0)))) (or (and (or (or x0 x5) (and x6 x3)) (and (and x3 x6) (not x3))) (and (or (not x1) (or x4 x5)) (and (or x1 x6) (not x4))))) (and (not (and (and (or x0 x4) (or x3 x6)) (or (and x2 x3) (not x6)))) (and (not (or (not x5) (not x2))) (not (not (not x2))))))) (not (or (or (or (and (or (and x3 x5) (or x0 x0)) (not (and x5 x5))) (and (and (and x0 x1) (or x6 x4)) (or (not x4) (and x6 x5)))) (and (and (not (not x0)) (or (not x4) (and x4 x2))) (or (or (and x6 x1) (not x6)) (not (or x4 x2))))) (and (or (or (not (not x1)) (or (and x4 x4) (not x5))) (and (not (not x5)) (not (and x0 x6)))) (and (or (not (or x3 x0)) (not (or x3 x5))) (or (not (and x2 x2)) (and (and x2 x4) (or x4 x1)))))))) (and (not (or (or (and (or (not (not x5)) (or (or x3 x1) (not x1))) (and (not (or x5 x3)) (not (or x3 x0)))) (not (and (not (or x2 x5)) (and (or x1 x0) (and x0 x5))))) (and (or (and (not (and x3 x1)) (or (and x1 x4) (not x5))) (or (or (not x2) (not x4)) (not (not x4)))) (and (not (or (and x5 x1) (or x4 x5))) (not (and (or x2 x1) (not x1))))))) (or (not (not (and (and (not (not x0)) (and (or x0 x3) (not x0))) (or (and (and x0 x6) (and x0 x4)) (not (and x6 x5)))))) (and (and (or (not (not (and x4 x3))) (or (or (and x1 x4) (or x3 x4)) (not (or x2 x2)))) (or (not (or (and x6 x0) (or x2 x3))) (not (or (and x3 x2) (and x6 x5))))) (or (and (not (and (and x6 x0) (not x0))) (or (and (not x5) (and x3 x3)) (not (or x0 x2)))) (and (not (or (and x5 x3) (not x0))) (or (and (and x6 x4) (or x2 x5)) (or (or x5 x1) (or x0 x2))))))))) (or (not (or (or (not (and (or (or (not x2) (or x3 x0)) (not (and x0 x2))) (or (not (and x3 x4)) (or (and x3 x4) (or x2 x6))))) (not (not (not (not (not x1)))))) (not (or (and (or (not (or x2 x3)) (or (or x4 x3) (or x3 x4))) (and (or (not x0) (and x3 x3)) (and (not x2) (and x0 x0)))) (and (or (and (and x1 x3) (and x0 x0)) (and (and x2 x2) (not x3))) (and (or (and x4 x0) (or x4 x4)) (not (or x5 x0)))))))) (and (or (not (not (and (or (and (not x2) (not x6)) (and (and x3 x4) (not x5))) (or (not (not x2)) (and (not x0) (not x3)))))) (and (and (or (or (or (not x0) (not x3)) (or (or x3 x1) (not x0))) (and (not (not x2)) (or (and x6 x2) (not x2)))) (and (and (not (or x4 x4)) (not (or x0 x0))) (and (not (and x5 x5)) (and (not x2) (and x0 x0))))) (not (or (or (or (and x4 x5) (and x2 x5)) (not (and x6 x3))) (not (not (or x5 x4))))))) (or (not (not (and (or (not (or x6 x3)) (not (not x1))) (not (or (or x6 x0) (or x4 x6)))))) (or (not (and (not (not (and x3 x4))) (not (not (not x5))))) (and (and (not (or (or x5 x4) (not x4))) (not (not (or x6 x1)))) (and (not (and (and x1 x0) (or x0 x1))) (and (and (and x5 x2) (and x2 x5)) (or (not x1) (or x6 x4))))))))))) +(check-sat) +(push 1) +(assert (and (and (or (not (or (not x5) (and x3 x3))) (or (or (not x4) (or x5 x2)) (not (or x2 x0)))) (and (not (not (not x4))) (and (and (not x3) (or x5 x0)) (not (or x3 x5))))) (and (or (or (not (and x6 x4)) (or (and x2 x6) (and x2 x1))) (or (not (not x4)) (not (and x6 x3)))) (or (and (not (and x3 x3)) (not (or x0 x2))) (or (not (or x5 x4)) (or (and x2 x2) (and x1 x5))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (not (or (or (or (and (or (not (or x1 x0)) (not (or x2 x0))) (not (and (and x4 x3) (or x0 x6)))) (and (and (and (or x4 x1) (or x1 x2)) (or (not x1) (not x6))) (not (and (not x4) (and x6 x1))))) (or (and (and (not (not x6)) (or (and x6 x3) (not x1))) (or (or (and x5 x6) (or x5 x5)) (or (or x4 x6) (or x5 x6)))) (and (not (or (or x5 x2) (not x3))) (or (or (and x6 x6) (or x0 x5)) (or (and x1 x2) (and x6 x5)))))) (and (and (and (or (or (and x6 x2) (or x3 x5)) (and (or x6 x1) (and x1 x1))) (not (not (not x5)))) (or (or (not (or x3 x1)) (not (not x0))) (or (or (and x0 x4) (or x6 x6)) (and (not x2) (or x6 x1))))) (and (and (not (not (or x0 x1))) (not (or (or x2 x1) (not x1)))) (or (and (not (or x5 x2)) (or (not x0) (not x6))) (and (and (or x2 x4) (not x5)) (or (and x6 x5) (and x0 x6)))))))))) +(assert (or (or (or (and x2 x5) (and x5 x3)) (not (not x5))) (not (not (or x6 x2))))) +(assert (not x3)) +(check-sat) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_28.smt2 b/test/regress/regress1/push-pop/fuzz_28.smt2 new file mode 100644 index 000000000..09933d521 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_28.smt2 @@ -0,0 +1,45 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (not (and (or (and (or (or (not (not (or (not x3) (or x9 x2)))) (and (not (or (and x8 x5) (and x0 x4))) (not (and (not x6) (not x1))))) (or (not (or (and (or x2 x9) (and x1 x9)) (not (not x2)))) (not (not (and (or x8 x0) (not x8)))))) (or (and (and (and (or (not x2) (not x5)) (not (or x1 x6))) (not (not (or x2 x4)))) (or (not (and (not x7) (or x1 x6))) (and (or (or x6 x7) (or x8 x7)) (not (and x0 x8))))) (and (not (and (and (and x2 x1) (and x0 x5)) (not (or x8 x8)))) (not (and (and (not x2) (or x5 x8)) (not (not x1))))))) (and (and (not (or (and (or (and x3 x3) (or x2 x5)) (and (or x8 x9) (not x2))) (and (or (not x5) (not x1)) (and (or x6 x7) (not x1))))) (not (and (and (and (or x1 x5) (and x4 x8)) (not (and x6 x4))) (and (or (or x0 x8) (and x3 x5)) (not (and x6 x1)))))) (not (and (and (not (or (or x0 x4) (or x9 x7))) (or (and (and x8 x4) (not x4)) (or (and x0 x5) (or x1 x9)))) (not (and (and (and x3 x5) (and x8 x6)) (and (or x9 x8) (or x2 x7)))))))) (or (or (or (or (or (not (or (or x8 x3) (or x3 x7))) (not (and (not x7) (or x1 x0)))) (and (or (and (or x5 x7) (or x3 x0)) (and (and x0 x6) (not x2))) (not (not (or x4 x3))))) (or (and (not (or (and x2 x4) (or x0 x6))) (not (and (and x6 x7) (not x3)))) (not (and (and (and x7 x5) (and x3 x0)) (and (not x8) (and x6 x1)))))) (and (not (not (not (or (not x2) (not x3))))) (or (or (not (and (not x8) (not x5))) (and (or (or x0 x1) (and x6 x1)) (not (not x1)))) (not (not (or (or x1 x5) (not x0))))))) (and (or (not (and (or (or (not x6) (not x7)) (and (not x3) (and x7 x3))) (and (not (not x0)) (and (not x1) (or x4 x6))))) (or (and (not (and (and x8 x7) (and x9 x7))) (not (or (not x2) (and x0 x6)))) (or (not (not (or x3 x3))) (not (not (or x9 x7)))))) (and (not (not (not (or (and x2 x2) (or x9 x7))))) (or (and (and (or (or x5 x7) (and x2 x0)) (and (or x8 x4) (not x7))) (not (not (and x6 x9)))) (and (not (not (not x0))) (or (and (not x9) (or x1 x7)) (not (or x9 x7))))))))))) +(assert (not (and (not (not (or x9 x8))) (or (not (not x9)) (or (and x4 x6) (or x3 x8)))))) +(assert (or (or (not (or (and (and (and x9 x5) (or x3 x6)) (not (not x9))) (and (and (and x7 x6) (and x8 x3)) (or (and x1 x8) (and x0 x9))))) (not (not (or (and (and x8 x7) (or x9 x2)) (and (not x1) (not x1)))))) (and (or (and (and (not (or x7 x2)) (not (or x6 x5))) (and (or (and x8 x6) (and x8 x7)) (or (not x6) (not x7)))) (or (or (not (not x3)) (and (and x0 x5) (not x4))) (and (not (or x7 x2)) (not (and x1 x9))))) (or (not (and (or (and x5 x4) (or x1 x0)) (or (and x6 x2) (not x1)))) (and (or (not (not x1)) (and (or x2 x7) (or x6 x1))) (not (or (and x2 x0) (not x4)))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (or (not (not (not (or (and (or (not x2) (and x1 x3)) (not (not x3))) (or (not (not x8)) (or (or x9 x7) (and x3 x3))))))) (not (or (and (not (or (or (and x6 x6) (not x6)) (and (not x1) (not x4)))) (and (not (not (and x9 x7))) (and (and (and x6 x9) (and x1 x2)) (not (or x3 x1))))) (or (or (or (not (not x9)) (not (and x4 x4))) (or (not (and x4 x0)) (or (not x0) (or x2 x0)))) (and (and (and (or x1 x1) (not x9)) (or (or x7 x7) (not x2))) (and (or (and x1 x7) (or x2 x9)) (and (not x2) (not x2)))))))) (and (or (not (and (not (and (not (or x5 x6)) (not (or x3 x8)))) (or (not (not (or x6 x3))) (and (or (or x6 x1) (not x9)) (not (or x8 x2)))))) (not (and (not (or (or (or x7 x1) (not x3)) (or (or x6 x9) (and x8 x1)))) (not (not (not (and x6 x7))))))) (or (not (not (and (and (or (not x3) (not x0)) (or (or x3 x3) (or x4 x3))) (or (and (and x8 x6) (or x7 x7)) (not (or x4 x4)))))) (and (and (and (not (or (or x2 x7) (not x6))) (and (or (not x2) (or x3 x6)) (and (not x8) (not x9)))) (and (not (and (or x1 x5) (and x6 x1))) (or (not (or x6 x1)) (or (or x0 x8) (not x5))))) (and (or (not (not (and x5 x3))) (or (not (or x8 x1)) (not (or x7 x4)))) (and (and (and (or x3 x0) (or x1 x4)) (and (or x6 x7) (not x1))) (or (or (not x0) (and x6 x5)) (not (not x4))))))))) (and (or (and (and (and (not (not (not (and x3 x6)))) (and (or (not (not x6)) (not (not x3))) (or (not (not x6)) (and (or x4 x9) (not x0))))) (and (or (not (not (or x5 x6))) (or (and (and x8 x2) (and x5 x2)) (or (or x0 x4) (or x4 x6)))) (or (and (or (not x0) (or x6 x4)) (not (and x5 x6))) (and (or (and x8 x7) (not x7)) (or (and x2 x5) (and x7 x5)))))) (or (and (not (not (or (not x7) (or x7 x8)))) (not (not (or (and x0 x9) (or x4 x6))))) (and (and (or (not (and x1 x4)) (not (and x5 x4))) (or (or (or x9 x0) (and x9 x9)) (not (or x7 x7)))) (or (not (or (not x3) (or x8 x0))) (or (not (or x3 x4)) (not (not x1))))))) (or (not (and (not (or (not (or x0 x6)) (or (not x9) (not x9)))) (or (not (not (and x6 x9))) (not (and (not x9) (and x8 x2)))))) (not (or (or (and (and (not x6) (or x7 x2)) (and (and x8 x5) (and x0 x8))) (and (not (not x7)) (or (not x6) (or x8 x9)))) (or (and (and (and x5 x6) (and x4 x2)) (and (or x1 x2) (not x4))) (not (and (and x4 x8) (and x7 x7)))))))) (or (and (and (or (or (or (and (and x5 x5) (or x8 x2)) (not (not x8))) (and (not (not x3)) (or (or x9 x8) (not x2)))) (and (or (and (and x4 x8) (and x7 x7)) (and (not x3) (and x8 x0))) (and (not (and x2 x5)) (and (and x9 x4) (and x5 x3))))) (not (and (or (not (not x7)) (and (not x1) (or x5 x1))) (not (not (and x6 x5)))))) (or (not (not (or (and (not x1) (or x1 x0)) (and (and x6 x8) (and x1 x0))))) (or (or (and (not (or x9 x2)) (or (and x5 x6) (and x1 x2))) (not (not (and x7 x2)))) (or (not (not (and x0 x3))) (or (not (and x8 x0)) (and (not x5) (not x7))))))) (or (or (or (and (and (or (and x9 x0) (or x1 x9)) (not (and x4 x4))) (and (and (not x8) (not x1)) (and (or x0 x9) (not x2)))) (not (not (not (not x2))))) (not (and (not (not (or x5 x1))) (and (or (not x9) (not x6)) (not (or x1 x6)))))) (not (or (or (and (and (or x5 x1) (not x1)) (and (not x4) (not x2))) (or (and (and x6 x2) (or x4 x3)) (and (and x1 x7) (and x8 x0)))) (or (or (not (or x9 x4)) (or (and x7 x8) (or x1 x6))) (or (or (or x0 x7) (and x6 x2)) (or (not x5) (not x0))))))))))) +(assert (not (and (and (and (and (or (and (or x7 x6) (and x4 x6)) (not (or x4 x2))) (and (and (or x7 x6) (or x9 x1)) (or (not x1) (and x1 x8)))) (not (not (and (or x7 x1) (not x7))))) (not (or (not (and (or x7 x2) (and x2 x2))) (or (and (or x5 x1) (and x8 x1)) (or (and x2 x8) (not x6)))))) (or (or (not (not (or (not x2) (or x2 x8)))) (not (and (not (not x9)) (not (and x9 x6))))) (and (or (or (not (and x1 x3)) (not (not x3))) (and (and (and x1 x4) (and x1 x9)) (not (or x1 x7)))) (not (not (or (not x2) (not x0))))))))) +(check-sat) +(push 1) +(assert (and (not (and (and (or (and (and (or (not (or x0 x2)) (not (and x3 x8))) (or (and (not x3) (or x1 x7)) (and (or x0 x3) (or x0 x0)))) (and (not (and (not x6) (not x9))) (or (not (and x9 x4)) (and (or x1 x3) (not x7))))) (or (not (and (and (not x9) (not x4)) (not (not x1)))) (not (or (or (or x7 x9) (and x0 x1)) (not (and x6 x3)))))) (or (not (not (or (and (not x5) (not x0)) (and (and x1 x9) (and x7 x1))))) (or (and (or (and (not x3) (or x9 x8)) (not (and x0 x6))) (not (not (not x5)))) (and (and (and (and x7 x6) (and x7 x2)) (and (not x9) (and x8 x1))) (and (not (not x4)) (not (or x5 x7))))))) (not (not (or (and (and (or (and x5 x6) (not x1)) (or (not x7) (not x6))) (and (or (and x3 x6) (or x4 x3)) (or (and x7 x3) (not x5)))) (or (not (not (or x7 x4))) (and (or (not x6) (or x4 x6)) (or (or x1 x3) (not x2))))))))) (or (and (not (and (or (and (not (not (and x3 x8))) (and (not (and x4 x9)) (not (not x0)))) (or (and (or (or x7 x5) (not x1)) (or (and x8 x0) (not x1))) (and (and (and x8 x9) (or x3 x2)) (not (not x9))))) (or (or (or (and (or x2 x6) (not x1)) (or (not x6) (not x4))) (or (or (not x4) (or x6 x7)) (and (and x8 x0) (and x3 x5)))) (or (and (not (or x1 x6)) (not (not x0))) (not (not (not x0))))))) (or (not (not (and (or (or (and x6 x5) (and x5 x6)) (not (or x9 x2))) (not (not (and x8 x0)))))) (or (not (and (not (not (and x1 x4))) (and (and (not x9) (and x4 x1)) (or (not x9) (not x7))))) (and (or (and (not (or x4 x1)) (not (and x9 x1))) (and (not (and x0 x4)) (and (or x8 x0) (not x5)))) (or (not (and (or x7 x1) (not x9))) (not (not (not x0)))))))) (not (or (or (not (or (and (not (not x3)) (and (or x5 x0) (not x1))) (not (not (not x8))))) (and (and (or (and (and x3 x3) (or x2 x3)) (not (or x5 x3))) (and (and (and x3 x2) (or x6 x8)) (and (or x8 x1) (not x9)))) (or (and (and (and x7 x0) (and x7 x4)) (and (and x8 x3) (not x4))) (not (not (not x8)))))) (and (not (and (not (and (or x6 x4) (or x9 x9))) (or (and (or x8 x3) (or x0 x0)) (not (or x0 x7))))) (or (and (or (and (and x5 x9) (or x7 x2)) (and (not x2) (not x4))) (and (or (not x8) (or x4 x4)) (not (or x9 x4)))) (or (not (not (and x0 x5))) (or (and (not x9) (not x5)) (not (or x7 x7))))))))))) +(assert (and (not (or x6 x8)) (or (or x4 x6) (or x4 x6)))) +(assert (or (or (not (not (and (or x3 x4) (or x4 x9)))) (or (not (and (not x2) (and x9 x7))) (and (and (and x4 x9) (not x2)) (not (and x8 x5))))) (or (or (and (not (not x3)) (or (and x9 x9) (and x1 x8))) (or (and (and x7 x3) (and x4 x8)) (not (not x4)))) (and (not (not (or x4 x5))) (and (or (or x7 x0) (and x2 x6)) (not (or x7 x7))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (and (or (not (and (or (or (or (not (not x9)) (not (and x2 x7))) (not (or (or x3 x5) (not x6)))) (not (and (and (and x9 x5) (and x2 x4)) (and (or x0 x9) (not x7))))) (and (or (not (and (not x8) (or x6 x7))) (not (and (or x7 x6) (or x3 x5)))) (and (and (and (and x4 x9) (or x0 x8)) (not (not x9))) (not (not (and x6 x1))))))) (or (not (and (and (and (not (or x0 x7)) (not (or x1 x7))) (and (or (or x4 x1) (or x3 x3)) (or (not x7) (or x3 x0)))) (or (and (and (not x6) (and x5 x0)) (not (or x8 x2))) (and (and (or x7 x0) (and x9 x8)) (and (and x0 x2) (not x2)))))) (and (not (not (not (and (not x2) (or x6 x1))))) (and (and (and (and (and x9 x7) (or x2 x0)) (and (or x5 x5) (and x6 x8))) (or (and (and x6 x9) (or x4 x1)) (not (and x5 x5)))) (and (not (and (not x0) (or x9 x1))) (not (not (or x0 x3)))))))) (or (not (and (not (and (or (not (or x2 x6)) (and (or x2 x6) (not x8))) (or (or (and x0 x9) (and x0 x0)) (or (or x3 x0) (and x3 x3))))) (not (not (and (or (or x2 x1) (and x5 x9)) (or (or x1 x1) (and x2 x5))))))) (and (not (or (and (not (or (or x4 x0) (and x6 x9))) (or (not (and x5 x5)) (and (and x0 x7) (or x7 x7)))) (not (not (not (not x9)))))) (or (and (or (and (and (and x2 x6) (and x6 x9)) (or (not x8) (and x3 x0))) (and (not (not x6)) (and (not x1) (or x3 x1)))) (not (or (and (and x8 x7) (and x0 x4)) (or (not x1) (not x0))))) (or (not (or (or (and x7 x1) (and x8 x7)) (and (or x3 x1) (or x6 x2)))) (and (not (not (not x0))) (not (and (or x2 x3) (or x5 x3))))))))))) +(check-sat) +(pop 1) +(assert (and x5 x7)) +(check-sat) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_29.smt2 b/test/regress/regress1/push-pop/fuzz_29.smt2 new file mode 100644 index 000000000..38e72425e --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_29.smt2 @@ -0,0 +1,46 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(check-sat) +(push 1) +(assert (and (or (or (not (and (not (or (or (not x5) (not x2)) (and (and x5 x2) (not x2)))) (or (or (and (not x2) (or x2 x1)) (or (or x3 x1) (and x3 x6))) (not (or (or x0 x4) (or x5 x0)))))) (not (and (not (or (not (and x1 x3)) (not (and x5 x4)))) (not (or (or (or x6 x0) (or x5 x3)) (and (or x4 x5) (or x4 x0))))))) (not (or (not (and (not (or (or x0 x6) (and x2 x2))) (or (and (or x3 x6) (or x1 x5)) (and (not x3) (not x3))))) (or (not (and (and (and x2 x3) (not x0)) (not (not x2)))) (not (or (not (and x1 x2)) (not (or x6 x6)))))))) (not (not (not (not (and (and (or (and x4 x2) (and x4 x4)) (or (and x5 x5) (and x0 x4))) (not (not (or x4 x0)))))))))) +(check-sat) +(pop 1) +(assert (and (and (not (and (or (not (or (or (or (not x1) (and x6 x5)) (and (and x2 x3) (and x5 x1))) (and (not (not x4)) (and (and x4 x5) (not x1))))) (and (and (not (not (not x5))) (or (or (and x6 x3) (and x3 x6)) (or (not x2) (not x0)))) (and (or (or (or x6 x4) (and x6 x1)) (or (and x1 x6) (or x1 x0))) (or (and (not x6) (and x2 x2)) (not (and x2 x0)))))) (and (and (or (or (not (and x1 x6)) (and (not x0) (not x4))) (or (and (not x4) (not x4)) (and (or x4 x1) (and x2 x1)))) (or (or (not (or x6 x0)) (and (and x6 x5) (not x0))) (and (and (and x2 x2) (and x0 x0)) (or (or x0 x0) (and x3 x4))))) (not (and (not (not (and x1 x5))) (and (and (and x1 x3) (and x4 x2)) (or (or x5 x2) (and x5 x1)))))))) (not (and (not (not (and (and (or (and x6 x2) (and x3 x0)) (or (or x3 x5) (and x4 x4))) (not (or (or x2 x3) (and x5 x6)))))) (or (not (not (or (and (not x2) (not x4)) (and (not x1) (and x1 x2))))) (and (or (and (not (or x5 x5)) (not (or x3 x1))) (and (and (and x4 x3) (or x1 x0)) (and (and x0 x3) (or x3 x3)))) (or (not (not (or x0 x0))) (not (not (and x0 x0))))))))) (or (not (and (or (not (or (not (not (or x5 x5))) (not (not (or x2 x6))))) (and (and (and (not (not x4)) (not (or x2 x4))) (not (or (and x0 x5) (or x4 x1)))) (or (or (or (not x6) (and x5 x2)) (or (not x1) (and x5 x1))) (or (or (and x5 x3) (or x3 x5)) (and (not x1) (or x0 x0)))))) (and (and (not (not (and (or x3 x0) (and x1 x2)))) (not (not (or (or x6 x0) (not x5))))) (not (or (or (not (not x4)) (and (not x6) (or x1 x4))) (and (or (or x6 x0) (and x3 x5)) (not (not x0)))))))) (not (not (not (or (and (or (or (or x0 x2) (and x0 x0)) (or (and x6 x6) (not x6))) (and (or (not x3) (not x2)) (and (and x0 x3) (or x6 x5)))) (and (or (not (not x3)) (or (or x1 x0) (and x2 x6))) (not (not (and x0 x2))))))))))) +(assert (not x6)) +(assert (or (not (or (and (and (not (not (not x0))) (and (not (not x3)) (or (not x5) (not x6)))) (and (or (or (or x0 x4) (and x0 x6)) (or (not x3) (or x3 x3))) (and (and (not x6) (and x2 x6)) (or (or x5 x3) (and x4 x6))))) (or (and (not (and (or x1 x3) (not x5))) (or (or (and x1 x4) (not x2)) (or (not x5) (or x1 x3)))) (or (and (and (or x4 x3) (and x2 x2)) (or (and x4 x0) (not x5))) (or (or (and x4 x1) (and x3 x5)) (and (or x5 x1) (not x2))))))) (or (or (and (and (not (and (or x4 x0) (not x5))) (and (not (or x2 x1)) (and (and x0 x0) (or x2 x2)))) (or (or (not (or x2 x3)) (or (and x4 x2) (not x4))) (and (and (or x3 x2) (or x1 x4)) (not (not x6))))) (or (or (not (not (or x2 x0))) (not (not (and x0 x0)))) (not (not (and (or x6 x4) (and x3 x5)))))) (or (or (not (or (and (and x4 x1) (or x1 x1)) (and (not x0) (not x5)))) (not (and (not (and x4 x1)) (and (or x3 x0) (and x5 x3))))) (and (and (not (not (not x6))) (or (or (not x5) (or x2 x5)) (and (and x5 x3) (or x3 x1)))) (or (not (and (not x2) (not x5))) (and (or (not x3) (not x5)) (not (not x6))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (or (or (not (and (and x2 x5) (and x5 x0))) (not (or (and x0 x0) (or x3 x6)))) (not (not (or (or x5 x1) (and x4 x0))))) (and (not (or (and (and x3 x1) (or x1 x3)) (not (not x0)))) (not (and (or (or x0 x2) (or x4 x2)) (or (and x6 x1) (or x6 x1)))))) (not (not (not (or (or (or x1 x1) (or x3 x0)) (or (and x3 x2) (or x4 x4)))))))) +(assert (not (and (not (and (not (and (and (and (not x1) (not x2)) (not (and x4 x2))) (or (or (or x5 x6) (and x0 x1)) (and (or x1 x5) (not x3))))) (or (and (or (not (not x4)) (not (and x2 x0))) (and (and (or x5 x3) (or x5 x0)) (or (not x3) (or x1 x3)))) (and (or (or (not x1) (and x5 x2)) (not (or x1 x0))) (or (not (and x2 x1)) (or (not x1) (and x6 x2))))))) (and (not (and (and (and (not (not x1)) (or (or x6 x0) (not x5))) (and (and (and x4 x1) (and x4 x4)) (not (or x3 x1)))) (or (and (not (and x5 x4)) (or (or x2 x2) (not x6))) (or (not (and x0 x2)) (and (or x6 x2) (or x1 x2)))))) (and (or (or (not (and (or x0 x4) (not x1))) (not (or (and x2 x4) (and x2 x2)))) (or (and (not (and x4 x4)) (not (and x3 x3))) (and (or (and x1 x0) (not x0)) (or (or x5 x6) (not x0))))) (or (or (and (or (not x5) (or x4 x1)) (and (not x4) (and x3 x5))) (or (not (and x3 x1)) (or (or x6 x1) (not x3)))) (and (or (not (or x0 x1)) (and (and x3 x6) (or x1 x1))) (and (and (and x0 x6) (and x5 x0)) (or (not x4) (or x5 x0)))))))))) +(check-sat) +(push 1) +(assert (not (and (or (not (and (not (and (and (and x6 x2) (not x0)) (and (or x5 x6) (and x4 x5)))) (or (or (or (and x4 x1) (not x1)) (and (or x6 x3) (not x3))) (or (and (and x6 x3) (or x4 x4)) (not (or x3 x3)))))) (not (or (or (or (and (or x4 x1) (and x1 x2)) (or (and x5 x3) (not x1))) (not (not (or x3 x3)))) (not (not (and (not x4) (and x6 x0))))))) (or (not (and (and (or (or (not x6) (not x1)) (or (not x5) (not x4))) (and (not (or x6 x4)) (or (not x0) (or x1 x6)))) (or (and (and (or x3 x4) (or x1 x5)) (or (not x2) (or x4 x1))) (and (and (and x6 x0) (and x2 x4)) (and (and x4 x6) (not x6)))))) (or (or (and (not (not (and x4 x4))) (not (and (not x1) (or x2 x2)))) (or (not (or (not x1) (or x6 x0))) (and (not (and x4 x5)) (and (not x5) (and x5 x4))))) (not (or (or (and (not x5) (or x0 x6)) (not (not x0))) (not (not (or x0 x1)))))))))) +(check-sat) +(push 1) +(assert (or (not (or (or (and (and x4 x3) (or x1 x4)) (and (not x4) (and x2 x0))) (and (or (not x4) (and x6 x6)) (and (and x5 x5) (not x4))))) (and (or (and (or (and x6 x3) (and x0 x2)) (or (or x3 x1) (or x2 x1))) (or (or (not x0) (not x1)) (and (or x2 x0) (or x5 x6)))) (and (and (not (not x0)) (or (or x3 x1) (or x3 x3))) (not (and (and x3 x0) (and x3 x1))))))) +(assert (and (or (or (or (and x3 x0) (or x3 x4)) (not (or x5 x6))) (and (and (and x2 x3) (not x4)) (or (and x4 x0) (not x6)))) (not (and (not (not x2)) (or (or x2 x1) (or x0 x2)))))) +(assert (or (not (or (or (or (and (or (or (and (or x4 x2) (and x2 x3)) (and (not x4) (or x4 x5))) (not (not (and x1 x6)))) (not (and (or (and x3 x4) (and x4 x3)) (and (and x1 x6) (or x1 x4))))) (or (and (or (and (or x3 x0) (and x1 x5)) (and (or x2 x1) (or x2 x2))) (or (or (and x3 x4) (and x6 x1)) (or (not x5) (or x0 x2)))) (and (not (and (not x4) (not x1))) (and (or (not x5) (or x2 x6)) (or (and x6 x4) (not x5)))))) (or (and (not (or (and (or x4 x3) (not x2)) (or (or x6 x6) (and x4 x0)))) (or (or (and (or x6 x5) (or x3 x3)) (and (or x6 x4) (not x4))) (not (not (and x4 x3))))) (not (or (or (or (and x5 x4) (or x0 x6)) (or (not x6) (and x2 x3))) (and (or (not x1) (or x6 x5)) (and (and x0 x2) (or x6 x6))))))) (and (and (and (and (or (not (not x6)) (and (and x5 x3) (and x2 x4))) (not (not (not x0)))) (and (or (or (and x6 x4) (not x4)) (not (or x3 x3))) (not (or (not x2) (and x1 x5))))) (or (or (or (or (and x3 x2) (not x1)) (not (not x6))) (and (not (not x4)) (and (not x6) (not x4)))) (or (and (not (or x2 x0)) (or (or x2 x5) (or x3 x3))) (and (not (not x2)) (not (or x2 x5)))))) (and (or (or (and (and (and x0 x0) (and x2 x5)) (not (and x4 x2))) (or (not (and x1 x0)) (not (and x3 x0)))) (and (and (or (or x0 x3) (not x4)) (or (not x5) (not x5))) (or (or (or x6 x2) (and x0 x5)) (not (and x0 x1))))) (or (not (not (and (not x0) (or x1 x6)))) (and (or (or (or x5 x6) (or x1 x5)) (not (or x2 x5))) (or (or (and x4 x2) (not x1)) (or (and x0 x0) (or x2 x6))))))))) (and (and (and (not (or (not (or (or (not x6) (and x4 x2)) (or (not x4) (and x4 x6)))) (or (or (and (not x1) (and x6 x1)) (or (not x4) (and x4 x5))) (or (and (not x3) (not x0)) (or (not x3) (or x6 x2)))))) (or (or (not (and (or (or x6 x1) (or x0 x1)) (not (and x0 x1)))) (or (or (or (and x5 x2) (and x6 x1)) (not (not x3))) (not (or (and x3 x2) (not x0))))) (and (not (not (and (or x2 x3) (not x1)))) (not (or (or (not x3) (not x1)) (and (and x2 x6) (and x2 x1))))))) (and (or (or (or (and (and (not x5) (or x4 x1)) (and (or x3 x5) (not x3))) (not (or (not x0) (or x2 x6)))) (not (and (or (or x2 x2) (or x6 x6)) (and (and x4 x6) (and x2 x1))))) (or (or (and (and (not x0) (and x0 x2)) (and (and x0 x4) (not x0))) (not (and (not x0) (and x2 x0)))) (not (or (and (and x3 x1) (or x5 x2)) (or (or x4 x3) (or x4 x4)))))) (and (or (not (not (and (or x0 x4) (not x4)))) (and (or (or (or x5 x5) (or x0 x5)) (or (or x6 x4) (not x5))) (and (not (or x6 x0)) (and (or x2 x6) (or x0 x6))))) (and (or (not (not (or x2 x0))) (or (not (not x5)) (or (not x4) (or x5 x0)))) (and (or (or (or x0 x6) (not x4)) (not (or x2 x0))) (and (or (and x2 x3) (and x5 x5)) (or (and x4 x5) (not x2)))))))) (and (not (and (or (and (not (or (not x2) (or x6 x1))) (or (and (or x1 x3) (and x0 x5)) (or (not x5) (or x0 x5)))) (and (and (and (not x3) (or x2 x1)) (or (or x3 x0) (not x5))) (or (and (and x5 x6) (and x6 x2)) (or (not x1) (not x6))))) (not (not (not (not (not x0))))))) (or (not (not (and (and (or (not x3) (not x3)) (and (not x5) (not x5))) (not (not (or x0 x3)))))) (or (not (not (not (not (and x1 x0))))) (or (or (not (not (not x0))) (or (or (or x0 x2) (and x1 x3)) (or (and x6 x4) (and x6 x6)))) (and (not (or (and x4 x1) (and x4 x0))) (not (or (and x6 x6) (or x6 x4))))))))))) +(check-sat) +(pop 1) +(assert (and (and (and x5 x2) (and x2 x2)) (not (and x1 x1)))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_30.smt2 b/test/regress/regress1/push-pop/fuzz_30.smt2 new file mode 100644 index 000000000..58f55bda0 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_30.smt2 @@ -0,0 +1,69 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (or (and (not (or (or (and (or (or x7 x2) (and x4 x1)) (or (or x0 x5) (and x1 x2))) (not (or (not x5) (or x8 x6)))) (not (or (or (not x0) (and x1 x1)) (not (or x4 x6)))))) (and (and (and (or (or (not x1) (or x3 x0)) (not (not x0))) (or (not (or x2 x7)) (or (and x2 x3) (and x0 x5)))) (or (and (not (and x3 x5)) (and (or x1 x7) (and x0 x7))) (not (and (not x2) (and x5 x0))))) (and (not (not (or (not x1) (or x0 x3)))) (and (not (and (or x2 x5) (and x5 x3))) (and (or (or x2 x5) (and x8 x6)) (or (not x2) (or x8 x6))))))) (or (or (and (not (and (not (or x4 x0)) (or (or x1 x6) (or x6 x0)))) (and (not (not (not x8))) (not (and (not x5) (and x2 x6))))) (not (not (or (not (not x8)) (not (and x7 x8)))))) (or (not (and (and (and (not x2) (not x5)) (and (not x1) (and x5 x0))) (not (not (and x5 x1))))) (and (not (or (not (not x0)) (not (and x8 x0)))) (not (or (or (or x8 x5) (not x8)) (and (not x4) (and x7 x0))))))))) (or (not (or (not (or (not (or (not (not x8)) (not (not x8)))) (and (and (not (not x6)) (not (or x1 x3))) (or (and (not x8) (and x6 x4)) (not (or x2 x1)))))) (not (or (or (and (and (not x4) (or x8 x7)) (or (and x0 x8) (and x4 x3))) (not (or (or x3 x7) (or x2 x5)))) (not (and (not (or x5 x1)) (not (not x8)))))))) (and (or (and (or (not (not (or (not x6) (or x0 x8)))) (and (and (and (not x5) (not x1)) (not (or x4 x4))) (and (and (not x3) (or x7 x6)) (not (or x8 x7))))) (not (and (or (not (and x8 x0)) (not (and x7 x6))) (and (and (or x0 x0) (or x3 x4)) (not (or x8 x5)))))) (and (or (not (or (not (or x5 x8)) (or (and x2 x2) (not x8)))) (or (not (not (not x0))) (or (and (and x1 x5) (not x3)) (or (and x1 x7) (not x2))))) (and (and (or (not (and x2 x7)) (not (or x7 x8))) (and (and (or x6 x1) (or x6 x4)) (not (and x3 x7)))) (and (or (not (or x7 x1)) (not (not x0))) (and (not (or x3 x6)) (not (not x7))))))) (or (or (not (not (and (not (or x4 x1)) (not (and x6 x3))))) (not (not (and (not (or x4 x7)) (or (and x5 x7) (and x2 x1)))))) (and (and (not (or (not (not x6)) (not (and x1 x3)))) (or (not (or (and x6 x4) (and x2 x2))) (or (or (or x7 x6) (not x3)) (and (and x3 x4) (not x7))))) (or (or (not (or (and x7 x4) (not x8))) (and (not (or x6 x5)) (and (and x6 x5) (and x4 x0)))) (and (not (or (not x4) (and x3 x8))) (and (not (not x8)) (not (not x4))))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (or (or (and (and (and (and (and x3 x7) (or x3 x2)) (or (and x7 x7) (and x6 x5))) (or (or (and x4 x5) (or x6 x6)) (and (and x4 x3) (and x5 x5)))) (and (and (or (or x5 x0) (and x8 x2)) (and (or x1 x6) (and x5 x0))) (or (not (and x8 x4)) (and (not x8) (or x0 x1))))) (and (or (or (and (not x8) (not x8)) (and (not x7) (and x8 x5))) (not (and (or x1 x3) (or x5 x0)))) (not (and (not (and x8 x1)) (not (not x2)))))) (and (or (and (not (not (or x2 x5))) (or (not (or x8 x8)) (and (not x6) (and x7 x8)))) (or (and (not (or x6 x2)) (and (not x1) (and x2 x2))) (not (or (or x6 x3) (and x6 x0))))) (not (or (or (not (or x1 x7)) (or (and x3 x6) (and x5 x6))) (and (or (not x0) (or x0 x2)) (or (not x2) (and x0 x8))))))) (not (or (or (not (not (and (or x5 x4) (or x4 x2)))) (and (not (or (or x1 x6) (not x8))) (or (not (not x3)) (and (or x4 x7) (and x2 x4))))) (and (not (not (or (or x0 x8) (not x4)))) (or (and (and (not x4) (and x2 x5)) (not (and x3 x5))) (and (not (or x0 x0)) (not (not x3))))))))) +(check-sat) +(pop 1) +(assert (or x3 x3)) +(check-sat) +(pop 1) +(assert (not (and (not (and (or x4 x1) (and x6 x3))) (and (not (and x3 x6)) (and (not x6) (and x5 x6)))))) +(assert (or (not (or (and (or (or (not (and x6 x7)) (or (not x8) (not x6))) (or (not (and x1 x8)) (or (not x6) (not x4)))) (and (and (or (not x4) (not x3)) (and (not x7) (and x4 x7))) (and (and (or x2 x7) (or x5 x2)) (and (not x1) (not x2))))) (not (not (or (and (and x5 x0) (not x1)) (and (and x4 x8) (not x1))))))) (not (and (not (or (not (or (or x7 x4) (not x1))) (not (not (not x2))))) (not (not (not (not (or x7 x7))))))))) +(check-sat) +(push 1) +(assert (or (and (not (or (and (or x8 x2) (and x3 x4)) (not (or x3 x4)))) (and (not (and (and x2 x4) (or x7 x1))) (not (not (or x7 x1))))) (and (not (not (or (and x5 x4) (or x2 x6)))) (and (or (or (and x1 x1) (or x2 x3)) (not (or x3 x1))) (or (and (or x6 x7) (or x2 x0)) (not (and x8 x0))))))) +(check-sat) +(pop 1) +(assert (and (or (not (and (or (or (or (and (not x0) (not x1)) (and (or x0 x2) (not x0))) (or (or (or x0 x0) (not x2)) (not (not x6)))) (and (not (and (or x5 x3) (not x5))) (not (or (and x1 x6) (and x0 x1))))) (and (or (and (and (or x6 x7) (and x6 x8)) (or (or x5 x7) (and x5 x3))) (not (not (not x7)))) (or (not (and (or x6 x3) (and x8 x3))) (or (and (and x6 x2) (and x3 x0)) (not (and x6 x0))))))) (and (and (and (or (or (and (and x3 x7) (or x0 x0)) (and (or x4 x4) (not x3))) (not (and (not x6) (and x7 x5)))) (and (or (not (or x1 x8)) (and (not x5) (or x8 x4))) (and (or (or x5 x1) (or x6 x3)) (not (not x2))))) (or (and (or (or (not x5) (and x2 x0)) (not (and x7 x1))) (and (and (and x1 x1) (not x6)) (or (not x0) (not x1)))) (and (or (and (or x8 x7) (and x1 x2)) (and (and x8 x0) (or x6 x7))) (not (not (or x6 x6)))))) (and (or (not (or (or (not x6) (or x1 x8)) (not (and x3 x3)))) (and (not (not (not x2))) (and (or (not x7) (and x5 x3)) (or (not x0) (and x5 x8))))) (and (and (or (not (and x1 x6)) (not (and x0 x4))) (not (or (or x8 x5) (not x8)))) (or (or (not (not x5)) (and (or x8 x1) (or x5 x4))) (or (and (and x4 x4) (not x3)) (and (or x1 x1) (and x7 x4)))))))) (or (and (and (or (or (not (and (not x8) (and x8 x0))) (not (and (and x4 x2) (not x2)))) (or (and (and (or x7 x6) (or x6 x7)) (not (and x1 x2))) (or (not (or x1 x6)) (not (not x3))))) (and (and (or (or (not x4) (not x5)) (or (or x1 x1) (and x5 x6))) (and (or (or x1 x8) (or x2 x0)) (and (not x4) (or x5 x4)))) (not (not (not (or x2 x4)))))) (or (not (or (or (or (and x8 x0) (or x4 x6)) (not (and x8 x0))) (and (or (not x2) (not x2)) (and (not x5) (not x2))))) (not (or (not (not (and x4 x8))) (not (not (or x1 x1))))))) (or (and (not (and (and (and (and x5 x5) (and x7 x6)) (or (and x1 x0) (and x1 x2))) (and (not (not x1)) (and (and x1 x0) (or x1 x8))))) (and (not (and (and (or x0 x2) (not x5)) (or (and x1 x3) (or x0 x2)))) (and (not (and (or x0 x3) (or x1 x1))) (not (or (or x6 x1) (or x5 x0)))))) (or (and (not (or (not (not x3)) (not (and x4 x3)))) (and (not (not (not x2))) (not (or (or x8 x2) (or x8 x2))))) (or (or (not (or (or x2 x0) (or x7 x0))) (and (or (or x4 x3) (not x7)) (and (and x7 x7) (not x1)))) (or (or (and (and x8 x8) (or x8 x0)) (or (not x0) (and x1 x7))) (or (not (or x1 x0)) (or (and x1 x3) (or x5 x3)))))))))) +(check-sat) +(push 1) +(assert (or (not (not (or (or (or x5 x4) (not x5)) (and (and x3 x7) (and x2 x7))))) (and (or (or (not (or x8 x6)) (not (not x1))) (not (not (or x5 x2)))) (or (and (or (and x5 x3) (not x3)) (or (not x8) (not x6))) (or (and (not x2) (not x8)) (not (not x8))))))) +(assert (and (and (and x1 x2) (or x4 x0)) (or (and x2 x6) (not x1)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (not (or (or (and (and (or (and (and x1 x1) (or x0 x0)) (not (and x5 x1))) (and (not (not x3)) (or (or x2 x4) (and x1 x2)))) (not (or (or (and x8 x2) (not x3)) (or (or x4 x1) (not x8))))) (or (or (and (and (not x8) (or x5 x0)) (or (not x3) (or x1 x2))) (and (and (and x6 x6) (not x5)) (not (not x6)))) (or (or (not (or x1 x7)) (or (and x6 x5) (and x5 x5))) (or (not (or x3 x6)) (or (or x8 x3) (and x4 x0)))))) (and (and (or (and (or (or x5 x8) (not x0)) (or (or x6 x2) (and x0 x3))) (and (not (and x1 x0)) (and (or x7 x4) (or x1 x7)))) (not (not (or (and x2 x3) (or x0 x6))))) (not (not (or (or (and x3 x5) (not x1)) (not (and x6 x4)))))))) (and (and (not (and (not (not (and (not x4) (and x1 x1)))) (or (not (and (or x2 x1) (or x0 x7))) (or (and (not x3) (and x0 x0)) (or (and x4 x1) (not x7)))))) (or (or (or (not (not (and x2 x1))) (and (or (and x5 x0) (and x5 x4)) (not (and x2 x6)))) (not (or (not (or x3 x2)) (not (and x1 x8))))) (or (not (or (and (not x8) (or x4 x8)) (and (not x0) (not x6)))) (not (and (and (and x2 x1) (not x8)) (and (not x6) (and x2 x8))))))) (or (not (not (or (and (or (not x7) (or x6 x0)) (not (not x8))) (or (and (not x0) (not x6)) (not (or x5 x2)))))) (not (or (and (not (and (not x5) (not x7))) (or (and (not x3) (or x4 x1)) (and (and x1 x1) (and x8 x2)))) (and (or (not (or x0 x6)) (not (or x8 x0))) (not (or (not x1) (or x5 x8))))))))) (or (and (or (and (and (and (or (or (or x2 x4) (not x8)) (and (and x5 x0) (not x6))) (and (and (and x2 x1) (or x8 x7)) (not (or x1 x2)))) (and (not (not (not x4))) (and (or (and x0 x0) (or x0 x8)) (not (not x3))))) (or (and (and (or (or x5 x8) (and x8 x5)) (or (not x2) (not x3))) (and (not (not x5)) (and (not x5) (or x6 x4)))) (not (or (or (not x6) (and x2 x7)) (or (or x8 x5) (not x2)))))) (or (and (or (or (not (or x6 x0)) (or (and x5 x4) (or x0 x0))) (or (and (or x6 x5) (not x1)) (and (not x7) (and x0 x4)))) (not (not (or (not x5) (and x0 x7))))) (not (and (not (not (not x2))) (not (or (or x0 x3) (and x3 x7))))))) (or (not (and (not (and (or (not x5) (and x4 x0)) (not (and x5 x1)))) (and (and (or (or x4 x3) (not x6)) (not (not x6))) (not (or (not x8) (or x0 x2)))))) (and (or (not (and (not (and x8 x7)) (and (not x6) (and x3 x8)))) (or (and (or (not x2) (or x6 x7)) (or (not x2) (not x1))) (not (not (not x2))))) (and (or (and (or (or x3 x6) (not x6)) (or (not x4) (and x2 x0))) (or (or (not x0) (and x6 x7)) (not (not x7)))) (and (not (and (and x5 x0) (or x2 x8))) (or (and (not x4) (and x8 x2)) (and (not x3) (not x2)))))))) (and (or (not (and (and (not (and (and x6 x5) (and x5 x3))) (or (and (and x7 x2) (or x4 x1)) (or (or x8 x0) (not x0)))) (not (and (not (not x0)) (not (and x2 x1)))))) (not (or (and (not (or (not x2) (not x5))) (or (or (and x3 x7) (or x4 x8)) (and (and x8 x1) (not x0)))) (or (not (not (or x0 x5))) (or (and (and x7 x0) (or x2 x5)) (not (and x0 x0))))))) (and (not (not (or (not (or (not x5) (not x6))) (and (not (and x4 x8)) (or (not x8) (or x3 x8)))))) (and (and (not (not (or (or x8 x8) (and x0 x4)))) (or (not (and (and x6 x2) (or x3 x6))) (and (not (and x6 x2)) (not (not x8))))) (or (or (and (and (not x5) (not x3)) (not (and x3 x7))) (and (not (and x4 x7)) (not (not x0)))) (or (not (or (not x6) (and x8 x6))) (not (or (not x8) (or x2 x1))))))))))) +(assert (or (or (or (not (and (and x4 x0) (or x0 x7))) (and (or (or x8 x3) (and x2 x0)) (and (and x4 x0) (and x1 x8)))) (not (or (or (not x8) (not x3)) (not (and x5 x7))))) (or (not (not (and (not x6) (and x8 x6)))) (or (or (or (and x7 x7) (or x7 x4)) (not (and x7 x3))) (or (and (not x8) (not x5)) (and (and x3 x4) (not x6))))))) +(assert (not (not (and (or x8 x1) (or x5 x7))))) +(check-sat) +(pop 1) +(assert (not (or (not (not (or (and (and (not (or x0 x1)) (not (and x5 x5))) (not (or (or x7 x4) (not x4)))) (and (not (not (or x6 x5))) (or (and (not x2) (and x6 x4)) (not (and x6 x8))))))) (not (and (or (and (or (or (and x0 x1) (not x5)) (not (not x8))) (and (and (and x4 x5) (or x8 x1)) (and (not x4) (and x4 x6)))) (not (not (or (and x4 x6) (or x7 x1))))) (not (not (or (not (not x8)) (not (and x6 x1)))))))))) +(assert (and (and x6 x5) (or x5 x0))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_32.smt2 b/test/regress/regress1/push-pop/fuzz_32.smt2 new file mode 100644 index 000000000..109b86ec0 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_32.smt2 @@ -0,0 +1,68 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (and (or x3 x1) (not x6))) +(check-sat) +(push 1) +(assert (or (or (or (not (not (or (not (not x6)) (or (and x3 x1) (not x4))))) (or (or (or (and (and x0 x1) (not x0)) (or (not x0) (and x0 x6))) (and (or (or x6 x0) (and x3 x1)) (or (or x3 x6) (and x4 x0)))) (not (not (or (not x4) (and x5 x3)))))) (and (not (or (not (and (or x1 x2) (and x1 x0))) (and (and (or x5 x0) (and x6 x2)) (and (and x4 x5) (not x3))))) (or (and (and (not (and x2 x0)) (or (or x1 x2) (and x2 x5))) (and (or (or x4 x3) (and x1 x3)) (not (not x5)))) (and (and (or (not x0) (not x4)) (or (or x5 x1) (or x3 x4))) (not (or (and x2 x4) (not x2))))))) (and (or (not (and (and (and (not x6) (and x1 x4)) (not (not x1))) (or (and (not x6) (or x2 x0)) (and (not x2) (or x0 x2))))) (not (and (not (or (or x6 x4) (or x2 x1))) (or (not (or x6 x4)) (or (not x5) (and x6 x2)))))) (or (not (not (or (and (not x4) (not x5)) (or (and x0 x6) (or x3 x3))))) (or (and (and (or (not x3) (or x2 x0)) (and (or x4 x5) (or x6 x1))) (not (or (and x5 x2) (not x4)))) (or (or (not (not x1)) (or (or x5 x4) (not x2))) (not (and (or x6 x4) (or x6 x1))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (or (not (and (or (or (not (or (or (and x3 x5) (or x6 x2)) (not (and x0 x4)))) (not (or (and (or x6 x0) (and x3 x2)) (not (not x3))))) (and (or (not (not (or x6 x2))) (and (and (or x0 x2) (or x6 x3)) (and (not x3) (not x6)))) (not (or (not (or x4 x4)) (not (not x0)))))) (not (not (not (or (not (and x2 x2)) (or (or x6 x4) (or x6 x2)))))))) (or (or (and (not (or (and (and (or x3 x3) (and x1 x0)) (or (not x6) (not x6))) (or (or (not x2) (not x2)) (or (not x6) (or x0 x5))))) (not (and (and (and (not x5) (or x0 x5)) (not (or x4 x3))) (not (and (and x3 x0) (and x3 x0)))))) (or (not (not (and (or (and x3 x0) (not x6)) (and (and x5 x6) (or x1 x0))))) (and (and (or (and (and x6 x0) (and x4 x1)) (or (or x4 x4) (or x0 x4))) (not (or (and x5 x6) (not x3)))) (or (or (not (not x4)) (and (not x2) (or x5 x5))) (and (or (and x0 x0) (not x4)) (and (or x2 x0) (not x6))))))) (and (not (or (or (and (not (and x4 x2)) (or (and x6 x2) (and x0 x1))) (and (or (not x3) (not x6)) (or (and x2 x3) (and x4 x3)))) (not (and (and (and x4 x0) (and x5 x0)) (not (or x0 x0)))))) (not (not (or (or (or (and x1 x1) (not x2)) (not (or x5 x0))) (or (or (or x2 x6) (and x4 x4)) (and (not x1) (and x3 x1))))))))) (and (or (and (or (or (not (and (or (and x0 x0) (and x0 x6)) (not (or x4 x5)))) (and (not (and (and x1 x3) (or x0 x5))) (or (not (not x5)) (not (or x4 x6))))) (and (not (not (not (and x4 x4)))) (or (or (and (not x2) (not x6)) (not (not x5))) (and (and (or x3 x5) (and x5 x1)) (not (or x4 x6)))))) (or (and (and (or (or (and x2 x5) (not x1)) (not (or x3 x5))) (not (or (or x1 x5) (and x6 x4)))) (or (or (and (or x1 x4) (or x3 x1)) (and (not x1) (or x5 x6))) (not (not (and x2 x4))))) (and (or (not (and (or x4 x3) (or x2 x0))) (not (or (and x3 x2) (or x0 x1)))) (not (not (not (and x1 x4))))))) (and (and (and (and (not (not (or x0 x3))) (and (not (or x0 x4)) (or (and x4 x3) (not x5)))) (or (or (not (not x1)) (and (and x4 x2) (or x1 x0))) (not (and (or x4 x4) (not x2))))) (or (or (and (or (and x4 x3) (or x2 x6)) (not (not x3))) (not (and (not x0) (or x4 x4)))) (or (and (not (or x3 x2)) (and (and x4 x0) (and x0 x1))) (or (not (or x0 x4)) (or (or x1 x2) (and x5 x0)))))) (not (not (and (and (and (not x4) (not x5)) (or (and x5 x0) (or x2 x5))) (not (or (not x3) (or x6 x3)))))))) (not (or (not (not (and (or (or (or x6 x3) (not x4)) (not (not x0))) (not (and (not x3) (not x2)))))) (not (or (or (not (and (not x6) (or x3 x0))) (not (or (not x1) (or x3 x0)))) (and (and (and (or x5 x2) (and x5 x2)) (or (not x4) (or x3 x0))) (and (and (not x0) (and x0 x0)) (and (not x6) (not x3))))))))))) +(assert (not (and (and (or (not (not (and (not (or x5 x2)) (not (not x6))))) (not (and (not (or (or x0 x5) (not x0))) (or (and (or x2 x2) (or x3 x6)) (or (or x4 x0) (and x0 x0)))))) (or (and (and (and (or (and x6 x0) (or x3 x6)) (and (or x2 x1) (or x6 x6))) (not (not (not x4)))) (not (or (not (and x6 x0)) (not (not x5))))) (or (and (not (not (not x6))) (and (not (not x1)) (and (and x2 x6) (or x2 x5)))) (and (not (and (or x4 x0) (and x4 x0))) (or (not (not x3)) (not (not x4))))))) (not (not (and (or (not (and (or x4 x1) (not x4))) (or (not (or x3 x6)) (not (or x0 x0)))) (not (or (not (not x2)) (and (not x4) (or x3 x1)))))))))) +(assert (or (or (not (not (not (not (not (and x2 x3)))))) (or (or (not (not (and (and x0 x2) (and x3 x4)))) (and (and (and (and x3 x3) (and x2 x2)) (not (or x0 x0))) (not (not (not x5))))) (and (not (or (not (or x6 x5)) (and (not x3) (and x5 x0)))) (and (not (not (not x4))) (not (not (and x5 x4))))))) (or (not (not (or (not (or (or x6 x5) (or x6 x1))) (or (not (or x2 x0)) (or (and x3 x6) (and x5 x3)))))) (or (or (or (or (not (not x4)) (and (and x0 x1) (and x3 x6))) (and (not (not x4)) (and (or x0 x3) (not x5)))) (not (not (not (and x2 x4))))) (not (and (not (not (not x5))) (and (and (or x2 x3) (not x1)) (not (and x4 x4))))))))) +(assert (and (and (or (or (not (not x2)) (and (not x3) (not x1))) (not (or (and x0 x0) (or x4 x4)))) (and (not (or (and x3 x3) (or x0 x0))) (and (and (or x5 x5) (or x2 x0)) (not (not x4))))) (not (and (or (and (and x4 x3) (not x6)) (not (and x5 x3))) (and (and (and x0 x4) (or x0 x3)) (and (not x1) (or x2 x1))))))) +(assert (not (or (not (and (and (and x6 x4) (not x5)) (not (and x4 x6)))) (and (or (or (and x2 x1) (and x3 x2)) (not (not x3))) (or (or (or x5 x0) (or x1 x3)) (and (and x3 x4) (or x4 x3))))))) +(check-sat) +(pop 1) +(assert (not (not (not (or x3 x2))))) +(check-sat) +(push 1) +(assert (not (and (not (and (and (or (or (not (not (and x4 x0))) (not (or (or x1 x2) (or x3 x1)))) (not (or (and (not x2) (and x4 x4)) (and (not x6) (not x4))))) (or (or (not (and (or x1 x5) (and x5 x5))) (not (or (or x5 x2) (or x1 x3)))) (not (and (and (not x3) (and x2 x5)) (or (or x3 x5) (and x4 x6)))))) (and (and (not (or (not (not x2)) (and (not x2) (and x4 x4)))) (not (and (and (not x5) (or x4 x0)) (not (and x5 x5))))) (or (not (not (not (not x1)))) (and (or (not (not x2)) (not (not x4))) (and (and (or x0 x1) (or x6 x4)) (or (not x4) (or x2 x3)))))))) (or (not (not (or (not (and (not (and x3 x4)) (not (not x6)))) (not (and (and (not x4) (or x1 x4)) (not (or x1 x5))))))) (and (and (not (or (or (and (or x5 x0) (or x3 x1)) (or (not x2) (or x0 x5))) (not (not (and x5 x4))))) (not (or (and (and (or x3 x3) (and x2 x6)) (and (and x3 x5) (and x1 x5))) (not (or (not x2) (not x0)))))) (and (and (and (or (and (or x3 x1) (or x6 x4)) (and (or x5 x3) (and x6 x1))) (or (and (or x2 x2) (or x6 x5)) (or (or x0 x0) (or x3 x5)))) (or (or (not (or x4 x4)) (and (and x0 x3) (and x5 x5))) (or (or (and x1 x3) (and x1 x5)) (and (and x1 x2) (or x2 x0))))) (or (and (or (and (or x0 x1) (not x4)) (and (not x4) (not x3))) (or (not (not x3)) (or (or x6 x4) (and x4 x4)))) (or (or (not (or x6 x5)) (and (or x2 x2) (and x2 x1))) (not (and (not x2) (or x1 x5))))))))))) +(assert (or x5 x5)) +(assert (or (or (not x5) (and x4 x3)) (not (and x1 x4)))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (and x1 x1)) (not (not x3)))) +(check-sat) +(push 1) +(assert (or (not (not x6)) (and (not x2) (or x6 x1)))) +(check-sat) +(pop 1) +(assert (or (not (not (and (not x3) (and x1 x4)))) (or (and (not (or x5 x0)) (not (or x1 x2))) (or (or (not x6) (or x3 x5)) (and (or x4 x5) (or x0 x6)))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (and (and x4 x3) (not x4)) (or (or x3 x5) (or x1 x6)))) +(assert (not (not (not (not (not (not x6))))))) +(check-sat) +(pop 1) +(assert (not (and (and (and (not (and x1 x1)) (or (and x5 x4) (not x1))) (not (and (or x0 x2) (or x0 x5)))) (not (and (and (or x0 x3) (and x4 x0)) (or (not x3) (not x1))))))) +(assert (and (or (not x3) (and x0 x2)) (not (not x2)))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_34.smt2 b/test/regress/regress1/push-pop/fuzz_34.smt2 new file mode 100644 index 000000000..e1ea02cad --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_34.smt2 @@ -0,0 +1,47 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (and (or (and (or (not (and (or (and (not x1) (or x0 x2)) (and (not x3) (and x1 x1))) (not (or (not x0) (not x6))))) (and (not (and (not (and x6 x5)) (not (and x2 x3)))) (or (or (or (not x0) (and x4 x0)) (or (and x3 x3) (and x4 x1))) (and (not (and x1 x2)) (or (and x4 x3) (or x2 x0)))))) (or (and (and (not (and (and x5 x0) (and x4 x2))) (or (not (and x1 x5)) (and (not x0) (or x0 x0)))) (not (not (and (not x0) (and x6 x2))))) (not (and (or (and (or x5 x5) (and x3 x3)) (and (not x0) (or x5 x1))) (not (or (or x0 x0) (or x0 x2))))))) (or (or (not (not (and (or (or x0 x6) (and x2 x0)) (and (and x3 x1) (and x2 x4))))) (and (or (or (not (or x6 x3)) (or (and x0 x4) (or x5 x5))) (not (and (not x4) (not x3)))) (or (and (and (or x2 x6) (and x4 x6)) (and (not x6) (not x5))) (and (not (and x2 x5)) (or (and x0 x2) (or x5 x4)))))) (not (or (or (not (not (not x0))) (or (not (or x4 x1)) (not (not x4)))) (or (and (or (or x5 x6) (not x0)) (not (or x5 x3))) (and (and (or x3 x1) (or x3 x2)) (or (and x0 x4) (or x3 x1)))))))) (not (not (not (not (not (and (or (and x6 x1) (or x4 x4)) (and (not x0) (and x1 x2)))))))))) +(check-sat) +(push 1) +(assert (not (or (not (or x6 x1)) (and (not x0) (and x3 x0))))) +(assert (not (or (and (and (not (not x4)) (or (and x6 x1) (not x1))) (not (and (not x1) (and x5 x3)))) (not (not (not (not x2))))))) +(check-sat) +(pop 1) +(assert (or (not (not (and (and (and (or (or (not (and x0 x3)) (or (not x2) (not x5))) (or (and (not x1) (not x5)) (or (not x1) (and x3 x0)))) (and (or (or (or x4 x1) (not x4)) (or (not x1) (not x4))) (or (not (and x3 x4)) (not (not x1))))) (not (or (not (not (and x2 x2))) (not (or (and x3 x5) (not x0)))))) (and (and (or (or (and (and x5 x1) (or x6 x6)) (not (and x4 x3))) (or (not (not x6)) (and (not x3) (or x2 x3)))) (not (or (not (or x4 x5)) (not (not x6))))) (and (and (and (and (or x2 x2) (or x1 x4)) (or (and x4 x2) (not x3))) (or (not (not x6)) (and (and x1 x0) (or x2 x4)))) (and (not (or (and x1 x5) (or x4 x1))) (not (or (or x3 x2) (and x5 x4))))))))) (not (or (not (not (and (or (and (or (not x4) (or x5 x6)) (not (and x1 x4))) (and (or (or x5 x5) (not x0)) (not (and x1 x2)))) (not (and (and (not x2) (not x2)) (and (or x5 x4) (not x2))))))) (or (not (or (or (or (not (or x2 x1)) (and (and x6 x5) (not x2))) (not (or (not x6) (not x4)))) (not (not (and (not x4) (and x6 x0)))))) (and (or (and (or (or (and x6 x0) (not x0)) (and (or x6 x1) (not x3))) (and (not (or x6 x2)) (not (or x1 x2)))) (and (and (or (or x1 x2) (and x0 x3)) (not (and x0 x4))) (and (and (not x0) (not x1)) (or (not x2) (and x4 x1))))) (or (and (or (or (or x1 x0) (not x3)) (or (and x6 x0) (or x2 x0))) (not (not (and x5 x0)))) (or (and (or (and x5 x5) (or x0 x2)) (or (not x1) (or x0 x6))) (or (and (not x3) (not x3)) (or (not x0) (and x1 x5))))))))))) +(assert (or (not (or x6 x5)) (and (not x3) (or x1 x3)))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (or (not (or (or (or (not x0) (not x3)) (and (or x3 x5) (or x3 x1))) (not (or (not x4) (or x1 x5))))) (not (or (and (and (not x2) (and x5 x5)) (not (not x1))) (or (not (and x2 x4)) (not (or x0 x5))))))) (and (and (or (not (and (not (and x1 x0)) (or (not x1) (and x6 x4)))) (or (not (and (and x1 x5) (not x4))) (and (or (or x3 x3) (and x3 x6)) (not (not x3))))) (not (not (and (and (and x1 x0) (or x3 x5)) (and (or x3 x1) (not x5)))))) (or (and (or (and (or (or x2 x5) (not x5)) (or (or x1 x2) (and x0 x0))) (and (not (not x2)) (and (and x3 x5) (not x1)))) (and (and (not (not x3)) (and (or x0 x3) (and x2 x6))) (and (and (not x6) (or x1 x6)) (and (and x0 x5) (or x0 x0))))) (not (or (and (not (not x4)) (and (not x0) (and x1 x3))) (or (or (not x3) (and x6 x2)) (and (not x5) (and x0 x3))))))))) +(check-sat) +(push 1) +(assert (and (not (or (or (not (not x2)) (not (not x2))) (not (or (or x3 x6) (and x6 x4))))) (or (and (or (or (not x3) (not x6)) (not (not x5))) (not (or (or x4 x6) (and x3 x6)))) (not (not (not (and x3 x6))))))) +(assert (or (and x4 x1) (and x6 x3))) +(assert (not (and (not (not (and x3 x0))) (and (not (not x1)) (or (or x0 x6) (and x2 x5)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and x4 x3)) +(assert (not (or (not (not x5)) (and (and x6 x6) (or x1 x0))))) +(assert (not (and (and (not (or (not (not x6)) (and (and x0 x5) (or x2 x1)))) (or (not (or (or x6 x3) (or x1 x2))) (and (and (and x5 x5) (or x3 x6)) (not (or x0 x6))))) (not (and (or (or (or x2 x2) (or x4 x4)) (and (or x1 x1) (or x4 x5))) (not (and (and x5 x2) (or x3 x3)))))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_35.smt2 b/test/regress/regress1/push-pop/fuzz_35.smt2 new file mode 100644 index 000000000..a2fc1e367 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_35.smt2 @@ -0,0 +1,43 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(assert (and (not (not (and (not (not (or (or (or x2 x1) (and x5 x0)) (or (not x3) (and x4 x0))))) (or (or (not (not (not x1))) (and (or (or x5 x4) (or x2 x0)) (and (not x3) (and x3 x2)))) (and (not (or (or x2 x4) (not x4))) (or (or (not x4) (not x1)) (and (and x3 x3) (and x4 x3)))))))) (or (not (or (and (and (not (not (or x0 x4))) (and (or (not x2) (or x4 x1)) (and (and x3 x3) (or x0 x3)))) (not (and (and (not x0) (or x3 x4)) (or (and x2 x5) (and x4 x3))))) (not (or (not (not (not x5))) (and (or (and x2 x3) (and x4 x1)) (and (and x0 x3) (not x1))))))) (and (not (not (or (or (and (or x3 x3) (and x4 x5)) (or (or x3 x5) (not x4))) (and (and (or x5 x3) (and x0 x3)) (or (not x4) (not x4)))))) (and (or (or (and (and (and x1 x4) (not x4)) (or (not x1) (and x5 x4))) (and (or (not x2) (and x5 x4)) (or (or x1 x3) (not x5)))) (and (or (and (not x1) (or x3 x1)) (and (or x3 x0) (or x5 x1))) (not (not (or x4 x5))))) (or (or (not (or (and x3 x0) (or x4 x3))) (and (not (and x2 x4)) (not (not x0)))) (or (not (or (and x0 x4) (and x2 x4))) (not (or (not x5) (or x2 x4)))))))))) +(assert (and (and (or (or (not (and (or (or x4 x3) (and x1 x3)) (and (and x3 x3) (not x5)))) (or (not (or (not x2) (not x4))) (not (or (or x1 x3) (not x3))))) (or (not (or (not (or x4 x1)) (and (not x2) (and x1 x2)))) (not (not (and (and x3 x4) (not x2)))))) (or (not (not (or (not (or x5 x5)) (not (or x3 x5))))) (and (or (or (not (and x2 x2)) (and (or x1 x3) (or x3 x5))) (and (and (or x1 x1) (or x4 x0)) (not (or x0 x1)))) (and (and (not (not x4)) (or (not x2) (or x0 x4))) (or (and (and x4 x5) (and x5 x4)) (or (and x0 x0) (and x3 x4))))))) (and (or (not (or (not (or (not x5) (not x0))) (and (and (not x1) (not x0)) (not (not x5))))) (or (and (and (or (or x1 x2) (or x1 x0)) (not (or x2 x2))) (or (or (not x4) (not x3)) (not (or x1 x4)))) (not (or (and (not x2) (or x2 x0)) (not (or x3 x3)))))) (or (or (not (not (and (and x0 x2) (and x4 x5)))) (not (not (or (not x4) (or x0 x3))))) (or (or (not (or (or x5 x0) (or x5 x1))) (or (not (and x5 x5)) (and (or x3 x1) (not x0)))) (not (or (not (not x3)) (not (and x1 x5))))))))) +(assert (or (and (or (or x4 x1) (or x1 x2)) (and (and x5 x3) (and x0 x2))) (not (not (and x2 x2))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (or (and (not (and (and (not (or (or x3 x4) (and x0 x0))) (or (or (and x4 x3) (and x1 x2)) (and (and x4 x4) (or x2 x4)))) (and (and (not (not x5)) (not (not x5))) (not (not (not x4)))))) (not (and (and (not (not (not x1))) (or (or (not x5) (not x4)) (or (and x3 x1) (or x5 x3)))) (and (and (not (and x1 x1)) (or (not x5) (or x0 x1))) (not (and (and x1 x3) (or x0 x0))))))) (or (not (or (not (and (not (or x3 x0)) (not (or x5 x4)))) (or (and (and (or x2 x0) (not x2)) (or (and x5 x2) (not x1))) (or (not (not x2)) (not (not x5)))))) (not (or (not (or (or (or x0 x1) (or x3 x5)) (and (and x2 x3) (and x2 x3)))) (not (or (or (not x5) (not x2)) (not (and x4 x5)))))))) (or (not (not (not (and (or (or (not x1) (not x5)) (not (not x4))) (or (and (and x2 x4) (or x5 x1)) (or (and x4 x2) (and x3 x1))))))) (and (or (not (or (or (not (not x4)) (or (not x3) (not x2))) (not (not (and x0 x1))))) (or (not (not (or (and x4 x1) (or x2 x1)))) (not (or (not (or x3 x3)) (and (and x5 x1) (or x5 x4)))))) (and (not (or (or (and (and x3 x2) (not x3)) (and (or x2 x5) (not x5))) (not (or (and x2 x1) (or x4 x4))))) (and (or (or (or (and x3 x1) (not x3)) (not (not x5))) (and (or (not x1) (or x1 x3)) (not (and x2 x2)))) (and (or (and (and x1 x1) (or x5 x0)) (and (or x3 x5) (and x5 x1))) (and (not (and x4 x4)) (and (and x4 x5) (or x1 x2))))))))) (and (and (and (or (and (or (or (or (and x4 x0) (not x0)) (and (or x5 x5) (or x1 x5))) (or (not (or x2 x4)) (and (or x1 x4) (not x4)))) (and (or (or (and x2 x1) (not x3)) (and (and x3 x0) (and x5 x4))) (or (not (not x4)) (and (or x2 x3) (or x4 x4))))) (and (not (and (and (and x5 x4) (or x4 x4)) (and (not x1) (not x4)))) (or (and (not (or x0 x3)) (not (or x0 x2))) (and (not (not x1)) (or (and x4 x3) (not x2)))))) (not (not (and (not (not (and x0 x2))) (or (and (or x3 x0) (or x3 x0)) (or (and x4 x3) (or x0 x5))))))) (not (not (or (or (or (and (and x3 x4) (and x2 x3)) (and (and x1 x0) (and x3 x4))) (not (or (and x0 x2) (not x4)))) (or (not (and (or x3 x1) (or x4 x0))) (and (not (and x5 x3)) (or (not x4) (not x0)))))))) (or (or (and (and (not (and (not (or x5 x1)) (or (and x5 x1) (or x4 x2)))) (not (not (or (not x3) (and x4 x2))))) (not (not (and (and (not x5) (not x2)) (and (or x5 x5) (or x1 x2)))))) (not (and (and (not (not (not x3))) (not (not (not x0)))) (not (or (and (or x3 x3) (not x2)) (and (not x2) (and x2 x1))))))) (not (not (and (not (or (and (not x3) (or x2 x2)) (or (not x2) (not x2)))) (or (and (or (and x3 x3) (not x0)) (and (not x0) (and x0 x0))) (not (or (not x3) (or x4 x2))))))))))) +(check-sat) +(pop 1) +(assert (and (or (not (and (or (not (and (not (not x3)) (or (and x3 x4) (not x0)))) (not (or (and (not x0) (not x5)) (or (or x3 x4) (or x4 x1))))) (or (or (not (not (and x3 x1))) (or (or (and x0 x1) (not x1)) (or (not x5) (not x3)))) (and (and (or (or x0 x5) (or x2 x3)) (and (or x4 x1) (or x4 x1))) (not (and (or x3 x5) (and x1 x4))))))) (not (or (and (and (or (or (not x4) (not x5)) (and (or x2 x5) (not x5))) (or (or (not x2) (and x4 x3)) (or (or x1 x1) (or x0 x3)))) (and (not (and (or x0 x4) (or x0 x3))) (or (and (not x0) (or x5 x4)) (and (or x2 x4) (and x0 x2))))) (and (not (not (or (or x3 x4) (or x4 x4)))) (and (and (not (or x2 x3)) (and (or x1 x0) (and x1 x3))) (or (or (not x2) (and x3 x0)) (and (not x5) (and x3 x0)))))))) (not (not (or (and (or (or (and (or x1 x3) (and x2 x1)) (not (or x3 x1))) (not (and (not x4) (or x4 x5)))) (or (not (and (and x1 x2) (and x1 x1))) (not (not (or x5 x0))))) (or (and (not (not (or x1 x4))) (not (and (or x1 x3) (or x3 x0)))) (not (not (and (and x0 x2) (or x0 x1)))))))))) +(assert (and (and (or (and (not (and (or (and (or x4 x2) (not x3)) (and (not x2) (and x0 x5))) (not (not (and x5 x4))))) (or (not (not (or (and x4 x4) (or x3 x1)))) (not (or (not (not x2)) (or (not x3) (not x2)))))) (and (not (or (and (or (not x4) (or x2 x1)) (not (not x1))) (and (or (or x4 x5) (or x1 x4)) (not (not x2))))) (or (not (not (not (not x5)))) (not (and (not (not x0)) (or (not x3) (or x5 x4))))))) (or (and (or (not (not (or (and x2 x4) (not x1)))) (not (or (or (not x2) (not x1)) (not (not x4))))) (or (not (and (not (or x4 x5)) (and (or x3 x5) (and x1 x2)))) (and (not (or (and x1 x3) (not x3))) (or (or (or x2 x0) (and x2 x4)) (or (or x3 x1) (or x4 x5)))))) (not (or (not (or (not (and x5 x4)) (or (or x1 x2) (and x5 x5)))) (not (or (not (not x4)) (not (and x0 x1)))))))) (and (and (not (and (and (and (or (and x4 x1) (or x5 x3)) (or (or x3 x3) (or x3 x2))) (or (not (and x3 x5)) (and (and x5 x2) (or x4 x2)))) (and (or (or (and x2 x3) (or x5 x2)) (or (not x0) (not x5))) (and (not (not x5)) (or (not x5) (not x4)))))) (not (and (not (not (and (not x0) (or x2 x2)))) (and (or (not (or x3 x5)) (not (not x1))) (not (and (and x5 x1) (and x2 x1))))))) (not (and (not (or (or (and (or x0 x2) (and x1 x1)) (or (or x2 x4) (or x5 x5))) (or (or (and x4 x0) (or x5 x5)) (not (not x1))))) (and (and (or (or (and x1 x4) (and x2 x5)) (not (and x0 x0))) (and (or (and x1 x4) (and x2 x1)) (or (and x1 x1) (and x5 x4)))) (or (or (not (and x1 x1)) (or (and x3 x2) (and x0 x5))) (not (and (or x4 x5) (and x3 x1)))))))))) +(assert (not (and (and (and (or x3 x0) (and x1 x5)) (and (or x4 x2) (and x3 x4))) (or (and (and x2 x0) (or x2 x2)) (or (not x0) (and x3 x4)))))) +(check-sat) +(push 1) +(assert (not (not (not (and (or (and (and (or (not (or x3 x0)) (and (and x1 x2) (and x1 x1))) (not (not (or x5 x1)))) (and (and (and (not x5) (and x2 x5)) (and (or x4 x2) (and x2 x3))) (or (or (or x1 x5) (not x2)) (and (and x2 x0) (or x4 x4))))) (or (or (not (and (and x3 x1) (or x5 x4))) (not (not (or x2 x1)))) (or (not (not (and x5 x2))) (or (not (not x3)) (and (and x3 x4) (not x1)))))) (not (not (not (and (not (not x3)) (or (not x2) (or x2 x3))))))))))) +(assert (and (not (and (or (or (or (and (not x4) (and x2 x2)) (or (and x3 x2) (and x0 x1))) (not (or (and x3 x4) (not x3)))) (and (and (or (and x0 x4) (and x1 x5)) (and (or x4 x2) (and x3 x4))) (and (or (not x4) (or x1 x3)) (not (not x0))))) (not (or (and (and (or x1 x0) (and x0 x0)) (or (and x5 x3) (or x2 x5))) (not (and (or x4 x3) (not x0))))))) (not (or (not (not (not (and (or x2 x1) (not x1))))) (not (or (not (or (or x3 x0) (or x3 x1))) (or (or (or x3 x5) (not x1)) (not (and x5 x5))))))))) +(check-sat) +(pop 1) +(assert (or (or (and x5 x2) (or x1 x1)) (or (not x5) (or x3 x2)))) +(assert (or (not (and (or (and x0 x5) (and x4 x5)) (or (not x4) (not x0)))) (not (or (not (not x4)) (or (not x5) (and x4 x2)))))) +(assert (not (or (not (or (not (or x1 x1)) (and (and x2 x5) (or x2 x5)))) (not (or (or (not x0) (and x5 x4)) (not (and x1 x3))))))) +(assert (not (or (and (or (not x1) (or x0 x2)) (and (and x1 x1) (and x2 x4))) (and (not (not x5)) (not (not x0)))))) +(assert (not (or (or (or (and x1 x2) (not x0)) (and (not x2) (and x0 x2))) (and (not (and x2 x4)) (and (and x5 x0) (or x2 x4)))))) +(assert (or (or (or x3 x0) (or x0 x0)) (and (not x0) (not x1)))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_37.smt2 b/test/regress/regress1/push-pop/fuzz_37.smt2 new file mode 100644 index 000000000..cf34c5d35 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_37.smt2 @@ -0,0 +1,54 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(assert (or (not (or (not (not x0)) (and (or x1 x0) (not x0)))) (and (and (or (and x1 x1) (and x0 x1)) (not (not x1))) (or (not (or x0 x1)) (or (not x1) (or x0 x0)))))) +(check-sat) +(push 1) +(assert (or (not (and (and (or (not (not (and x1 x1))) (not (and (or x1 x0) (or x0 x1)))) (or (not (and (not x0) (and x0 x0))) (and (and (or x1 x0) (and x1 x1)) (not (not x1))))) (not (and (or (or (and x1 x0) (and x1 x1)) (not (or x1 x1))) (and (not (not x0)) (not (or x1 x1))))))) (and (not (and (or (and (and (not x0) (not x0)) (or (or x0 x1) (or x0 x1))) (not (and (or x1 x0) (and x1 x0)))) (and (not (or (not x1) (not x1))) (not (or (or x0 x1) (and x0 x0)))))) (not (or (and (or (and (and x0 x1) (or x1 x0)) (or (or x0 x1) (or x1 x1))) (and (not (not x1)) (and (not x1) (not x1)))) (not (or (not (or x0 x0)) (and (or x0 x1) (or x0 x0))))))))) +(assert (not (not (not x0)))) +(assert (or (not (or (or (or (not (not (or (and (not x0) (or x0 x1)) (or (not x0) (and x1 x1))))) (not (or (and (not (or x1 x0)) (not (not x0))) (not (or (and x0 x0) (not x0)))))) (and (not (not (or (or (or x1 x1) (and x1 x1)) (or (and x1 x0) (and x0 x0))))) (not (or (and (not (and x0 x0)) (not (not x0))) (or (and (not x1) (not x0)) (or (or x0 x1) (or x1 x0))))))) (and (and (and (and (and (not (or x1 x1)) (and (not x0) (not x0))) (not (and (or x1 x1) (not x0)))) (and (not (and (and x0 x0) (or x1 x1))) (not (not (not x1))))) (or (and (or (or (not x0) (or x0 x1)) (not (and x1 x0))) (and (or (or x1 x0) (and x0 x0)) (and (and x0 x1) (or x0 x1)))) (not (not (not (or x0 x0)))))) (and (not (not (and (not (or x0 x0)) (and (not x0) (not x1))))) (and (or (and (or (not x0) (and x1 x0)) (and (and x1 x0) (or x0 x0))) (or (not (not x0)) (and (not x0) (or x0 x1)))) (and (and (not (or x1 x0)) (or (or x0 x1) (and x1 x0))) (and (or (and x1 x1) (not x1)) (or (or x1 x0) (or x0 x0))))))))) (or (and (and (not (not (or (and (not (not x1)) (and (or x1 x1) (and x1 x1))) (or (or (and x0 x1) (or x0 x0)) (or (not x0) (and x1 x1)))))) (not (and (not (and (or (or x1 x0) (not x0)) (not (not x1)))) (not (and (or (or x0 x0) (and x1 x1)) (not (or x1 x1))))))) (or (and (not (not (not (not (and x0 x1))))) (not (not (or (and (not x0) (or x0 x1)) (or (not x0) (or x0 x0)))))) (not (or (and (and (and (and x0 x1) (or x0 x1)) (or (not x0) (or x1 x0))) (not (and (and x1 x1) (and x0 x1)))) (not (not (not (or x0 x1)))))))) (not (and (or (not (not (or (not (and x0 x1)) (or (not x0) (and x0 x1))))) (and (not (not (or (or x0 x0) (or x1 x0)))) (or (or (or (or x0 x0) (and x1 x1)) (and (or x0 x1) (not x0))) (not (and (not x1) (and x1 x0)))))) (and (and (and (not (or (and x1 x0) (not x0))) (not (not (and x1 x1)))) (not (not (or (and x1 x1) (or x0 x1))))) (not (and (and (and (or x0 x0) (and x1 x1)) (not (not x0))) (not (or (and x0 x1) (and x0 x0))))))))))) +(check-sat) +(pop 1) +(assert (or x0 x1)) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (or (and (and (and (and (and x0 x1) (and x1 x1)) (or (not x1) (not x0))) (and (or (not x1) (and x0 x1)) (not (and x0 x0)))) (and (not (not (or x1 x0))) (and (not (or x0 x0)) (and (and x1 x1) (and x1 x0))))) (not (not (not (not (not x0))))))) (not (and (not (and (or (not (and x0 x0)) (or (not x1) (not x1))) (or (or (and x0 x0) (and x0 x0)) (or (or x0 x1) (or x1 x0))))) (or (not (not (and (and x0 x1) (or x0 x0)))) (or (or (or (and x1 x0) (not x1)) (and (or x0 x0) (or x0 x0))) (and (and (or x1 x0) (or x0 x0)) (or (or x0 x1) (not x0))))))))) +(check-sat) +(push 1) +(assert (or (not (or (or (not (or (not (or (and x1 x1) (not x1))) (or (and (or x0 x0) (not x0)) (not (not x1))))) (and (not (or (and (not x0) (or x1 x1)) (and (not x0) (or x1 x1)))) (and (not (not (and x0 x1))) (and (not (not x1)) (or (not x1) (not x0)))))) (not (and (not (not (or (and x1 x0) (and x1 x0)))) (or (not (or (and x0 x0) (not x0))) (and (not (and x1 x1)) (not (not x1)))))))) (and (and (and (and (or (not (and (or x1 x0) (not x1))) (and (and (and x0 x0) (not x0)) (and (or x1 x1) (and x0 x0)))) (and (and (not (not x0)) (not (or x1 x0))) (or (or (not x0) (and x1 x1)) (not (not x0))))) (not (not (not (not (not x0)))))) (not (not (or (and (or (and x0 x1) (and x1 x0)) (or (not x1) (not x0))) (not (and (and x0 x1) (or x1 x1))))))) (or (or (or (or (not (or (not x0) (or x0 x0))) (and (not (or x1 x1)) (not (not x1)))) (not (or (and (or x1 x1) (not x1)) (and (not x0) (and x0 x1))))) (not (and (not (or (or x1 x1) (or x1 x1))) (not (or (not x0) (or x0 x1)))))) (or (or (and (or (or (not x1) (not x0)) (or (and x0 x1) (not x1))) (not (or (not x0) (not x1)))) (and (not (or (and x0 x0) (or x1 x0))) (or (not (not x0)) (or (or x1 x0) (not x0))))) (not (not (and (and (and x1 x0) (and x1 x0)) (and (not x1) (and x0 x0)))))))))) +(assert (not (or (or (or (not (and (or (not x0) (and x1 x1)) (and (and x1 x1) (or x1 x0)))) (and (or (not (or x0 x0)) (and (or x1 x0) (not x0))) (not (or (or x0 x1) (not x1))))) (or (not (and (and (not x0) (or x1 x1)) (or (or x1 x0) (and x1 x1)))) (or (and (not (and x1 x1)) (not (and x0 x0))) (not (and (not x1) (and x1 x0)))))) (or (and (and (and (not (and x1 x0)) (and (not x0) (or x0 x1))) (and (or (and x0 x1) (or x0 x0)) (not (not x1)))) (or (not (or (not x0) (not x1))) (or (and (and x0 x1) (and x1 x0)) (or (or x1 x0) (or x0 x1))))) (not (or (and (or (not x1) (or x0 x0)) (and (and x0 x0) (or x0 x1))) (not (and (and x1 x1) (not x0))))))))) +(check-sat) +(push 1) +(assert (or (and (or (or x0 x0) (or x1 x0)) (or (not x0) (or x0 x0))) (and (not (or x1 x0)) (not (not x1))))) +(assert (or (or (and (and (and x0 x1) (not x0)) (and (and x0 x1) (or x0 x0))) (or (or (or x1 x1) (and x0 x0)) (not (not x1)))) (not (or (not (not x0)) (not (or x1 x0)))))) +(check-sat) +(push 1) +(assert (or (or (not (not (and (not (not x0)) (or (or x0 x1) (and x0 x1))))) (and (not (and (and (or x1 x0) (and x1 x0)) (not (not x0)))) (not (and (and (and x0 x0) (and x1 x1)) (and (or x1 x0) (not x0)))))) (and (not (not (or (and (and x1 x0) (not x1)) (or (and x1 x1) (or x1 x0))))) (not (or (and (and (not x0) (not x1)) (or (and x1 x0) (or x1 x0))) (and (or (not x1) (not x1)) (or (not x1) (or x1 x0)))))))) +(assert (or (and x1 x1) (not x0))) +(check-sat) +(pop 1) +(assert (or (or (or (and (not (and (or (and x1 x1) (and x1 x1)) (and (and x0 x0) (not x0)))) (not (and (not (or x0 x0)) (or (not x1) (not x0))))) (not (or (and (not (and x1 x0)) (not (or x1 x1))) (not (or (not x1) (not x0)))))) (and (not (not (or (or (or x0 x0) (not x1)) (and (or x0 x1) (or x1 x1))))) (not (not (or (or (not x1) (not x0)) (or (not x0) (not x1))))))) (or (and (and (and (not (and (and x0 x1) (and x0 x0))) (and (or (and x0 x1) (not x0)) (or (not x1) (or x1 x0)))) (or (and (not (and x1 x0)) (and (or x0 x1) (or x1 x1))) (and (or (not x1) (not x0)) (not (or x0 x1))))) (not (or (or (or (not x1) (not x0)) (not (and x0 x1))) (or (not (not x0)) (or (or x1 x0) (and x0 x0)))))) (not (and (not (and (and (or x1 x0) (not x0)) (or (or x0 x0) (not x0)))) (and (not (or (not x0) (or x0 x0))) (and (or (and x0 x1) (or x0 x0)) (not (and x1 x1))))))))) +(assert (or (and (or (and (or (and (and (or x1 x0) (not x1)) (and (and x0 x1) (not x0))) (not (or (and x1 x0) (or x0 x1)))) (and (or (not (or x0 x0)) (not (not x0))) (not (or (not x0) (or x0 x0))))) (and (not (and (and (and x1 x0) (or x1 x0)) (and (or x1 x1) (not x1)))) (not (not (not (and x1 x0)))))) (and (not (and (not (and (or x1 x1) (or x0 x0))) (not (or (or x1 x1) (and x0 x0))))) (and (or (not (not (not x0))) (not (not (or x0 x0)))) (and (or (and (or x0 x1) (and x1 x1)) (and (not x1) (and x1 x0))) (and (or (and x0 x0) (not x0)) (or (not x1) (not x0))))))) (and (not (and (or (not (and (and x0 x0) (not x0))) (not (or (and x1 x1) (not x0)))) (or (not (or (not x1) (not x0))) (or (not (and x0 x0)) (and (or x0 x1) (and x1 x1)))))) (not (not (and (not (not (or x1 x1))) (not (not (or x1 x0))))))))) +(assert (not x0)) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_39.smt2 b/test/regress/regress1/push-pop/fuzz_39.smt2 new file mode 100644 index 000000000..abadcc2c1 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_39.smt2 @@ -0,0 +1,82 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(check-sat) +(push 1) +(assert (and (or (and (and (not (or x2 x1)) (not (or x5 x3))) (or (and (not x3) (or x1 x3)) (or (and x1 x0) (and x5 x0)))) (and (not (or (not x5) (not x0))) (not (and (or x5 x0) (and x4 x2))))) (and (not (not (not (not x0)))) (or (and (not (or x2 x3)) (and (or x0 x2) (not x2))) (or (not (not x3)) (or (and x1 x3) (and x2 x2))))))) +(check-sat) +(push 1) +(assert (not x1)) +(check-sat) +(push 1) +(assert (or (or (and (and (or (not (not x3)) (not (and x4 x2))) (and (and (or x4 x3) (and x2 x3)) (or (or x3 x5) (and x2 x5)))) (and (and (not (or x2 x4)) (not (or x5 x1))) (not (not (and x1 x0))))) (and (and (or (and (not x1) (not x4)) (not (and x5 x3))) (and (and (or x0 x3) (not x4)) (or (and x0 x0) (not x5)))) (not (not (not (and x2 x4)))))) (or (or (and (not (not (or x5 x4))) (or (or (and x0 x5) (or x3 x3)) (or (not x5) (and x4 x5)))) (and (and (not (and x4 x0)) (or (or x4 x3) (and x0 x3))) (or (or (or x5 x0) (and x1 x4)) (or (and x1 x5) (or x1 x4))))) (and (or (not (and (and x2 x3) (not x2))) (and (and (or x1 x2) (or x3 x1)) (and (and x4 x5) (not x3)))) (or (and (not (not x3)) (not (and x5 x2))) (and (and (or x0 x4) (and x3 x0)) (not (and x5 x4)))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (not (or (not x0) (not x4))))) +(assert (not (not (and (and x0 x0) (not x0))))) +(check-sat) +(pop 1) +(assert (or (or (not (and (or (or (and (and (or x1 x1) (not x5)) (or (or x1 x5) (and x4 x1))) (or (or (or x0 x1) (or x4 x1)) (and (or x1 x4) (and x1 x1)))) (not (not (or (or x0 x2) (and x0 x2))))) (not (and (and (not (not x0)) (not (and x1 x2))) (not (not (and x4 x3))))))) (not (not (and (not (and (or (or x3 x3) (and x3 x3)) (or (not x2) (or x4 x3)))) (not (and (or (or x0 x4) (and x1 x2)) (or (not x0) (and x1 x0)))))))) (or (and (and (not (not (and (or (or x5 x4) (and x5 x0)) (and (and x1 x1) (not x2))))) (and (or (not (not (and x1 x0))) (or (not (and x2 x5)) (or (and x4 x2) (and x2 x2)))) (not (not (and (and x4 x2) (not x5)))))) (and (not (not (and (or (not x1) (and x4 x2)) (and (not x1) (and x0 x4))))) (and (not (not (and (or x2 x4) (not x1)))) (or (or (or (or x4 x0) (or x4 x5)) (and (and x0 x2) (or x2 x2))) (not (not (or x4 x2))))))) (and (or (not (and (and (not (or x2 x3)) (and (or x4 x5) (not x2))) (not (not (or x2 x1))))) (or (or (and (or (or x3 x3) (not x4)) (and (not x3) (not x4))) (and (or (and x1 x4) (and x3 x5)) (or (or x4 x3) (or x4 x2)))) (not (not (or (or x0 x1) (and x1 x3)))))) (or (or (not (or (or (not x5) (not x5)) (or (and x1 x3) (and x1 x4)))) (not (not (not (not x2))))) (not (or (and (or (and x0 x2) (not x1)) (not (not x3))) (not (or (or x1 x2) (or x5 x0)))))))))) +(check-sat) +(push 1) +(assert (and (and (or (or (not (and (and (and (or (and x0 x1) (not x0)) (and (and x0 x4) (and x3 x3))) (not (and (not x5) (not x2)))) (not (and (not (not x0)) (not (not x4)))))) (not (or (not (and (not (and x4 x1)) (and (or x2 x3) (or x4 x1)))) (and (and (and (or x4 x3) (or x0 x1)) (not (or x0 x5))) (or (or (and x2 x2) (not x0)) (and (or x2 x3) (or x5 x5))))))) (or (or (and (or (and (not (and x5 x1)) (not (or x1 x3))) (not (not (or x2 x3)))) (and (or (not (or x3 x3)) (not (and x0 x2))) (and (not (not x2)) (or (or x2 x2) (and x1 x1))))) (not (or (and (and (and x4 x2) (not x0)) (not (or x4 x5))) (and (not (not x1)) (or (not x4) (not x0)))))) (and (not (or (or (and (not x1) (or x2 x3)) (and (and x2 x5) (or x2 x4))) (or (not (or x2 x5)) (not (not x5))))) (or (or (or (not (and x0 x4)) (and (and x2 x3) (or x3 x4))) (or (and (not x2) (or x5 x0)) (or (and x4 x3) (and x5 x0)))) (or (not (not (and x3 x5))) (or (and (or x2 x0) (and x4 x4)) (or (not x2) (and x3 x1)))))))) (or (not (and (and (or (or (or (or x2 x0) (or x0 x5)) (or (not x2) (and x0 x5))) (and (and (not x4) (not x3)) (and (or x3 x2) (or x5 x1)))) (not (and (or (not x5) (and x3 x2)) (and (and x0 x1) (not x2))))) (and (or (not (and (not x3) (and x0 x1))) (not (not (and x5 x3)))) (and (not (not (not x2))) (not (not (and x4 x0))))))) (and (or (not (and (not (and (or x4 x2) (or x5 x3))) (and (or (or x2 x3) (and x4 x1)) (and (and x1 x1) (or x1 x4))))) (not (or (or (or (not x1) (and x4 x3)) (or (and x5 x3) (not x2))) (or (not (or x1 x5)) (and (not x4) (or x4 x5)))))) (and (or (or (and (not (or x4 x2)) (and (or x3 x2) (not x4))) (not (and (and x3 x1) (or x1 x0)))) (and (or (and (or x0 x2) (or x3 x5)) (not (or x2 x0))) (or (not (not x3)) (and (and x4 x1) (or x1 x4))))) (not (not (not (and (or x1 x5) (and x2 x3))))))))) (and (or (or (not (or (not (and (not (not x3)) (not (not x5)))) (not (and (or (and x3 x4) (or x5 x3)) (not (and x2 x5)))))) (or (or (or (not (or (not x0) (not x4))) (and (and (and x3 x4) (and x0 x4)) (or (or x5 x4) (not x0)))) (or (not (not (and x2 x4))) (not (and (not x2) (or x3 x3))))) (or (and (not (not (not x2))) (or (and (and x1 x4) (not x2)) (not (not x4)))) (not (or (and (and x3 x4) (or x5 x0)) (or (not x2) (or x2 x5))))))) (or (or (or (or (or (not (and x1 x0)) (not (or x0 x3))) (or (or (and x2 x1) (and x1 x5)) (not (or x4 x0)))) (or (and (not (and x1 x5)) (not (not x3))) (or (or (not x1) (not x3)) (not (and x1 x5))))) (and (or (and (and (and x2 x3) (and x4 x0)) (and (not x0) (not x4))) (and (and (not x5) (and x5 x5)) (and (or x4 x5) (and x4 x0)))) (and (or (not (and x2 x0)) (not (not x1))) (not (not (not x3)))))) (and (not (or (and (not (not x0)) (and (and x3 x4) (or x4 x0))) (not (and (not x3) (not x0))))) (not (or (not (or (or x3 x5) (not x2))) (and (or (or x1 x4) (and x1 x1)) (not (or x0 x1)))))))) (and (and (or (or (and (and (not (not x3)) (not (not x1))) (or (and (not x0) (or x5 x2)) (not (or x3 x4)))) (not (not (or (and x2 x4) (not x3))))) (and (or (and (and (and x3 x0) (and x1 x0)) (not (not x3))) (or (not (and x1 x5)) (and (or x0 x5) (not x5)))) (not (or (or (and x5 x2) (or x0 x0)) (not (not x3)))))) (not (or (and (and (or (and x2 x2) (and x1 x3)) (not (or x5 x3))) (or (and (or x3 x0) (or x5 x2)) (or (and x2 x1) (or x5 x3)))) (or (not (or (not x1) (not x4))) (or (and (not x5) (and x0 x3)) (and (or x2 x2) (and x5 x0))))))) (or (not (or (or (and (or (or x4 x1) (or x5 x1)) (not (and x2 x4))) (not (and (or x0 x3) (and x4 x4)))) (or (and (or (or x1 x4) (not x5)) (or (or x2 x2) (or x3 x4))) (not (not (or x3 x4)))))) (or (or (or (or (and (or x0 x5) (not x4)) (or (or x4 x2) (and x3 x4))) (or (not (not x3)) (not (or x4 x0)))) (and (and (not (or x4 x4)) (or (not x4) (or x0 x2))) (not (or (and x1 x5) (not x5))))) (not (and (or (or (and x2 x3) (not x5)) (or (and x3 x2) (or x3 x3))) (or (and (and x5 x3) (and x4 x5)) (and (and x0 x0) (and x3 x3))))))))))) +(assert (and (and (or (and (not (or (and (or (not x4) (not x3)) (and (or x0 x0) (and x4 x3))) (and (not (not x2)) (and (and x2 x4) (and x0 x1))))) (and (not (and (and (or x0 x5) (not x0)) (not (and x1 x5)))) (or (not (and (and x1 x2) (not x5))) (not (not (not x3)))))) (and (not (and (and (or (and x5 x2) (not x0)) (not (or x3 x2))) (and (or (and x0 x1) (and x3 x5)) (or (not x1) (not x1))))) (and (or (and (and (and x0 x4) (not x0)) (not (and x0 x2))) (or (and (not x4) (or x0 x2)) (and (and x1 x3) (not x0)))) (and (and (not (and x3 x0)) (and (and x2 x4) (or x0 x3))) (and (or (or x5 x5) (and x0 x4)) (not (or x3 x5))))))) (not (not (or (or (and (and (and x0 x3) (or x3 x1)) (and (not x4) (not x2))) (not (and (and x0 x5) (and x3 x4)))) (and (or (or (not x3) (and x5 x3)) (not (or x5 x4))) (and (not (not x2)) (not (not x4)))))))) (not (or (and (not (or (or (and (and x3 x2) (not x1)) (and (not x5) (or x0 x4))) (and (and (or x2 x0) (not x1)) (not (or x4 x5))))) (not (or (and (or (not x0) (or x0 x4)) (not (or x4 x5))) (not (not (not x2)))))) (and (or (and (not (and (not x5) (and x5 x0))) (or (not (not x3)) (and (not x4) (and x2 x3)))) (not (or (not (not x1)) (and (not x4) (or x4 x0))))) (and (not (not (and (or x2 x0) (and x1 x5)))) (not (and (and (not x3) (not x2)) (and (not x5) (and x2 x4)))))))))) +(assert (not (or x0 x1))) +(assert (or (not (and (or (or (or (or x2 x2) (or x3 x3)) (or (or x0 x2) (not x2))) (and (not (or x4 x2)) (not (not x2)))) (or (not (or (and x4 x1) (or x5 x4))) (and (not (not x1)) (and (and x2 x5) (and x2 x5)))))) (or (or (and (not (not (not x0))) (and (not (not x1)) (or (or x2 x1) (and x1 x1)))) (and (or (or (and x1 x5) (or x5 x1)) (not (and x1 x2))) (not (not (and x1 x3))))) (or (not (not (not (not x4)))) (or (not (and (and x4 x0) (and x0 x4))) (and (not (not x1)) (not (not x0)))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (and (or (or (not (and (not (and (or x2 x2) (not x0))) (and (and (or x5 x4) (not x3)) (and (or x3 x3) (or x5 x3))))) (not (and (not (and (or x2 x2) (or x2 x4))) (or (or (not x0) (or x1 x0)) (and (or x2 x5) (not x5)))))) (not (or (and (not (and (and x2 x3) (not x4))) (not (or (not x2) (or x0 x4)))) (not (and (not (not x4)) (or (and x2 x5) (and x2 x4))))))) (or (not (not (not (or (not (or x2 x5)) (or (and x3 x1) (or x2 x3)))))) (and (and (not (and (not (not x3)) (and (or x2 x1) (not x1)))) (and (not (not (or x4 x4))) (and (or (or x0 x5) (or x3 x1)) (not (or x3 x3))))) (not (not (or (or (and x0 x4) (or x3 x1)) (not (or x0 x4)))))))) (not (not (not (or (not (or (not (not x4)) (not (or x1 x3)))) (and (not (not (not x5))) (and (not (or x1 x3)) (not (and x4 x4)))))))))) +(check-sat) +(pop 1) +(assert (and (and (not (not (or (or x1 x0) (not x4)))) (not (and (and (or x2 x0) (not x5)) (or (not x5) (and x3 x2))))) (or (and (or (not (not x2)) (not (and x1 x3))) (and (not (or x2 x3)) (or (and x3 x0) (and x4 x2)))) (not (or (not (not x3)) (not (or x0 x5))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (and (and (and (not x2) (not x5)) (or (not x0) (and x4 x3))) (and (or (and x1 x2) (not x0)) (or (not x3) (and x3 x0))))) +(assert (and (not (not x5)) (and (or x2 x0) (or x2 x1)))) +(assert (or (and (and (and (and (or (and (not (or x4 x2)) (or (not x0) (and x3 x5))) (and (not (and x1 x2)) (or (not x3) (and x2 x3)))) (or (not (or (or x1 x1) (or x0 x5))) (not (or (or x3 x5) (or x1 x3))))) (not (and (not (not (and x4 x0))) (not (and (or x5 x3) (or x0 x5)))))) (or (or (not (not (or (or x3 x0) (not x0)))) (or (and (or (and x2 x4) (not x4)) (and (and x0 x3) (not x0))) (not (or (or x4 x1) (or x3 x4))))) (and (or (and (and (not x4) (not x2)) (not (not x3))) (not (not (or x2 x1)))) (or (or (or (and x4 x5) (and x4 x4)) (and (not x5) (and x3 x1))) (not (and (or x2 x3) (not x1))))))) (not (or (not (and (or (not (not x5)) (or (not x0) (and x0 x4))) (and (not (and x5 x3)) (or (not x5) (and x4 x0))))) (or (not (not (and (not x1) (or x2 x1)))) (not (or (or (or x5 x0) (not x0)) (not (and x2 x4)))))))) (and (or (or (or (not (or (not (and x2 x3)) (and (and x3 x5) (and x5 x0)))) (and (or (and (and x4 x4) (and x2 x1)) (not (not x3))) (not (and (not x3) (not x0))))) (not (not (not (and (not x3) (or x1 x0)))))) (not (or (or (and (and (not x0) (or x0 x4)) (and (or x3 x4) (or x5 x4))) (and (not (and x1 x5)) (not (and x4 x0)))) (and (not (and (not x4) (and x2 x5))) (or (and (and x1 x4) (not x3)) (or (or x1 x5) (or x0 x3))))))) (or (or (not (not (not (not (and x4 x1))))) (not (and (or (or (or x5 x0) (not x3)) (not (not x4))) (and (and (not x1) (and x1 x4)) (or (not x5) (and x2 x2)))))) (or (not (not (and (or (or x2 x2) (or x0 x2)) (and (or x0 x5) (or x5 x1))))) (not (or (and (and (or x2 x3) (or x5 x0)) (and (and x0 x5) (and x3 x0))) (not (and (or x4 x3) (or x1 x1)))))))))) +(assert (or (or x4 x1) (not x5))) +(check-sat) +(pop 1) +(assert (or (or (or (or (and (not x5) (or x4 x2)) (not (or x4 x3))) (not (and (and x1 x2) (and x0 x0)))) (and (not (not (not x2))) (or (and (not x0) (not x3)) (and (or x4 x4) (not x3))))) (or (and (or (and (or x3 x0) (not x5)) (not (not x0))) (not (or (not x5) (or x2 x5)))) (or (and (and (not x0) (not x3)) (or (and x5 x0) (not x5))) (not (not (or x3 x0))))))) +(assert (or (and (or (or x0 x3) (or x3 x4)) (not (or x5 x3))) (or (and (or x2 x3) (not x4)) (not (not x1))))) +(assert (and (or (or (not (not (or (not (and (or (or x2 x0) (and x3 x4)) (and (not x4) (not x5)))) (or (or (not (or x5 x4)) (or (not x5) (or x5 x2))) (and (not (and x2 x2)) (or (or x5 x1) (or x3 x2))))))) (not (or (and (and (not (and (and x5 x2) (or x0 x0))) (not (and (not x3) (not x2)))) (not (and (not (or x4 x4)) (and (not x1) (or x3 x3))))) (or (or (or (not (not x5)) (and (and x2 x0) (not x2))) (or (not (and x4 x3)) (or (or x2 x2) (and x0 x0)))) (not (not (or (not x0) (not x0)))))))) (and (or (or (or (or (or (not (and x2 x5)) (and (or x4 x5) (and x2 x2))) (or (or (or x2 x1) (and x0 x5)) (and (not x2) (not x1)))) (not (or (not (or x1 x3)) (or (or x5 x5) (or x1 x0))))) (and (and (not (or (not x5) (not x2))) (not (or (or x5 x0) (not x2)))) (not (and (and (not x1) (and x5 x2)) (and (not x0) (and x0 x4)))))) (and (or (not (not (or (and x4 x2) (and x4 x1)))) (not (not (not (or x1 x1))))) (or (and (or (or (not x2) (not x3)) (or (or x1 x2) (or x5 x1))) (or (or (or x4 x2) (or x4 x3)) (and (and x5 x1) (and x0 x1)))) (or (and (not (and x2 x4)) (or (and x5 x2) (and x1 x2))) (not (and (or x4 x1) (or x0 x1))))))) (and (and (and (or (or (not (not x1)) (not (or x0 x4))) (not (and (or x5 x5) (or x4 x1)))) (not (or (or (not x2) (and x1 x1)) (and (and x1 x0) (or x5 x4))))) (and (not (or (or (or x4 x3) (not x4)) (not (or x3 x2)))) (and (or (and (and x3 x2) (and x3 x0)) (not (or x5 x3))) (and (or (and x1 x1) (or x1 x3)) (and (not x5) (not x1)))))) (or (not (not (not (not (or x5 x0))))) (or (or (or (and (and x0 x4) (not x3)) (and (or x1 x0) (not x0))) (and (and (and x0 x0) (or x0 x2)) (not (or x4 x5)))) (not (or (and (or x0 x2) (and x1 x4)) (and (or x3 x5) (not x4))))))))) (or (or (and (and (or (or (not (or (and x1 x1) (and x1 x2))) (or (or (and x3 x2) (not x1)) (and (or x1 x3) (not x4)))) (and (and (and (or x2 x3) (not x1)) (or (not x1) (and x1 x0))) (not (not (and x4 x0))))) (and (or (and (and (or x3 x0) (and x2 x1)) (or (and x3 x5) (or x0 x5))) (or (or (or x3 x1) (or x2 x2)) (or (and x5 x2) (or x3 x1)))) (and (and (and (not x5) (not x0)) (and (or x0 x0) (or x3 x4))) (not (or (and x0 x3) (not x5)))))) (and (and (not (not (or (not x2) (and x2 x1)))) (or (and (not (not x4)) (and (not x3) (not x0))) (and (and (or x5 x1) (or x4 x5)) (not (and x5 x3))))) (or (and (or (and (and x3 x0) (and x5 x0)) (not (not x0))) (and (not (not x2)) (and (or x1 x3) (and x5 x4)))) (not (or (not (and x0 x1)) (or (or x0 x1) (or x4 x5))))))) (or (or (not (and (not (and (and x5 x4) (not x5))) (or (not (or x4 x1)) (not (and x4 x1))))) (or (or (and (and (or x5 x4) (or x2 x0)) (or (or x0 x5) (not x0))) (and (and (not x3) (and x2 x4)) (and (or x2 x0) (or x1 x4)))) (and (and (not (or x0 x3)) (or (and x3 x0) (not x4))) (and (or (and x0 x5) (or x3 x4)) (and (and x5 x3) (or x2 x3)))))) (and (not (not (or (not (and x5 x2)) (not (and x0 x4))))) (not (and (and (and (not x5) (not x4)) (and (or x5 x1) (not x1))) (or (not (or x0 x4)) (not (not x3)))))))) (not (not (and (or (or (or (and (or x3 x4) (not x4)) (not (or x1 x0))) (and (or (or x1 x1) (and x2 x5)) (or (or x5 x2) (not x5)))) (not (not (not (not x5))))) (or (or (and (or (or x5 x1) (not x3)) (and (and x3 x3) (not x1))) (and (and (not x4) (or x4 x2)) (or (or x4 x5) (and x4 x5)))) (or (and (not (and x2 x1)) (or (or x2 x5) (or x1 x4))) (or (and (or x5 x0) (not x5)) (not (or x3 x2))))))))))) +(check-sat) +(push 1) +(assert (or (not (or (or (or (or (or (not (or (not x2) (or x5 x5))) (or (or (and x4 x2) (not x4)) (or (not x1) (or x3 x2)))) (or (and (or (or x2 x3) (and x5 x0)) (and (or x0 x2) (not x2))) (or (not (not x2)) (or (and x0 x3) (or x2 x3))))) (or (and (not (and (or x3 x2) (and x3 x2))) (not (and (and x0 x1) (not x1)))) (or (not (and (and x5 x1) (or x0 x5))) (not (and (and x1 x5) (and x1 x1)))))) (or (and (and (or (or (not x5) (not x2)) (and (and x3 x4) (not x4))) (or (and (not x0) (or x3 x1)) (not (or x3 x0)))) (not (not (or (or x2 x3) (not x0))))) (and (not (and (or (or x0 x5) (and x3 x3)) (and (and x5 x5) (and x3 x5)))) (not (not (or (not x5) (and x2 x0))))))) (and (or (not (not (not (or (and x0 x4) (not x4))))) (not (not (not (not (or x3 x4)))))) (or (or (and (not (or (or x2 x1) (and x0 x2))) (and (or (and x1 x2) (and x5 x2)) (or (or x5 x5) (and x1 x5)))) (or (not (and (and x3 x5) (and x1 x1))) (not (or (not x3) (and x2 x4))))) (not (not (or (and (not x5) (or x2 x2)) (or (and x5 x4) (and x3 x5))))))))) (or (not (or (and (and (or (and (and (or x1 x3) (not x0)) (or (or x2 x5) (or x3 x1))) (or (not (or x3 x5)) (or (not x2) (and x3 x5)))) (not (or (and (or x5 x1) (and x4 x1)) (or (not x3) (or x2 x1))))) (or (not (not (not (or x2 x1)))) (and (not (and (and x0 x4) (or x1 x4))) (not (not (not x0)))))) (not (and (not (and (or (and x3 x5) (not x3)) (or (or x2 x0) (or x0 x0)))) (and (not (and (or x2 x4) (or x2 x3))) (and (or (not x1) (and x4 x3)) (or (or x0 x5) (or x3 x5)))))))) (and (and (or (and (not (or (not (not x5)) (not (and x2 x2)))) (not (or (and (or x4 x1) (or x3 x2)) (or (and x4 x3) (or x1 x1))))) (or (or (or (not (and x0 x4)) (and (not x5) (and x2 x3))) (and (and (and x4 x3) (not x1)) (not (not x2)))) (or (not (not (not x3))) (not (or (not x2) (not x3)))))) (or (or (or (and (or (or x4 x1) (not x0)) (or (and x2 x0) (not x4))) (not (not (or x5 x3)))) (and (and (not (not x0)) (and (and x1 x4) (and x4 x5))) (not (or (not x0) (or x5 x2))))) (or (or (and (or (or x1 x4) (or x4 x2)) (or (and x0 x1) (not x3))) (or (or (and x1 x1) (and x3 x0)) (and (or x4 x1) (and x1 x1)))) (not (and (and (not x0) (not x0)) (or (and x1 x0) (or x5 x0))))))) (or (or (and (or (and (or (not x0) (or x0 x1)) (and (not x2) (and x3 x2))) (or (or (or x0 x3) (not x0)) (or (and x5 x5) (not x5)))) (or (not (not (and x3 x1))) (and (or (not x2) (or x3 x4)) (and (and x5 x1) (or x3 x4))))) (or (or (and (or (and x0 x4) (and x5 x4)) (or (not x0) (or x1 x1))) (and (not (and x1 x5)) (or (or x3 x4) (and x1 x3)))) (not (and (or (not x5) (not x2)) (and (not x5) (not x2)))))) (or (or (and (not (and (not x3) (or x2 x2))) (and (not (not x1)) (and (and x0 x2) (and x5 x4)))) (and (not (and (and x0 x5) (and x5 x3))) (and (or (and x3 x0) (or x1 x4)) (or (or x4 x5) (and x4 x5))))) (not (not (or (not (and x3 x4)) (or (or x5 x2) (or x2 x0))))))))))) +(assert (and (not (and (not (not (not (or (and x5 x1) (or x2 x2))))) (not (not (not (and (or x2 x4) (and x0 x1))))))) (not (or (or (and (or (and (and x3 x3) (and x5 x0)) (not (and x0 x3))) (and (not (not x5)) (or (and x2 x2) (and x3 x3)))) (not (not (or (and x2 x5) (and x3 x3))))) (or (not (and (or (and x4 x3) (or x3 x1)) (and (or x1 x0) (or x1 x3)))) (not (and (and (or x4 x1) (not x0)) (not (not x5))))))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_1.smt2 b/test/regress/regress1/push-pop/fuzz_3_1.smt2 new file mode 100644 index 000000000..bf2d2a8c3 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_1.smt2 @@ -0,0 +1,31 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (not (<= (+ (* (- 24) x0 ) (* (- 15) x2 ) (* (- 18) x2 ) ) 2)) (not (< (+ (* (- 21) x2 ) (* 6 x2 ) ) (- 11))) (> (+ (* (- 3) x0 ) (* 8 x1 ) ) 11) )) +(assert (not (> (+ (* (- 4) x2 ) (* (- 23) x2 ) ) (- 26))) ) +(assert (or (not (< (+ (* 35 x2 ) (* 40 x0 ) (* 38 x0 ) ) (- 4))) (not (<= (+ (* 46 x0 ) (* (- 16) x1 ) ) (- 44))) (> (+ (* 33 x2 ) (* (- 47) x2 ) (* (- 38) x0 ) ) 32) )) +(assert (or (<= (+ (* 49 x2 ) (* 42 x0 ) (* 36 x0 ) (* (- 15) x0 ) ) 41) (not (= (+ (* 5 x2 ) (* (- 2) x0 ) ) (- 23))) )) +(assert (or (< (+ (* 9 x1 ) (* (- 16) x1 ) (* 47 x2 ) (* 2 x0 ) ) (- 18)) (not (>= (+ (* 43 x0 ) (* (- 24) x1 ) ) (- 22))) (not (< (+ (* (- 37) x1 ) (* (- 27) x2 ) (* (- 40) x0 ) (* (- 34) x0 ) ) (- 42))) )) +(assert (or (not (<= (+ (* (- 26) x1 ) (* (- 20) x0 ) ) 26)) (<= (+ (* 24 x0 ) (* (- 40) x2 ) ) (- 50)) )) +(check-sat) +(push 1) +(assert (or (< (+ (* (- 23) x0 ) (* 25 x2 ) ) 47) (not (>= (+ (* (- 3) x0 ) (* 20 x1 ) (* (- 22) x0 ) ) 4)) (<= (+ (* (- 14) x0 ) (* 32 x2 ) (* 2 x0 ) (* 13 x1 ) ) (- 3)) )) +(assert (or (>= (+ (* (- 6) x0 ) (* (- 22) x2 ) ) (- 41)) (not (< (+ (* 26 x0 ) (* 15 x1 ) ) 6)) )) +(assert (<= (+ (* (- 14) x2 ) (* (- 39) x0 ) (* (- 31) x1 ) ) 24) ) +(assert (or (> (+ (* (- 27) x2 ) (* (- 35) x1 ) ) (- 46)) (< (+ (* (- 41) x0 ) (* 46 x1 ) (* 16 x2 ) (* (- 31) x2 ) ) 29) (not (<= (+ (* (- 44) x2 ) (* 46 x0 ) (* (- 33) x1 ) ) (- 14))) )) +(check-sat) +(assert (not (>= (+ (* 23 x2 ) (* 5 x1 ) ) (- 16))) ) +(assert (or (>= (+ (* (- 3) x0 ) (* 3 x1 ) (* 44 x0 ) ) (- 39)) (> (+ (* 28 x1 ) (* 26 x1 ) (* (- 22) x2 ) (* (- 36) x2 ) ) 27) (not (= (+ (* 16 x0 ) (* 41 x2 ) (* 16 x2 ) ) (- 47))) )) +(check-sat) +(pop 1) +(assert (not (<= (+ (* (- 28) x1 ) (* (- 11) x0 ) (* 9 x0 ) (* (- 4) x0 ) ) 23)) ) +(assert (not (< (+ (* 16 x1 ) (* (- 18) x2 ) ) 34)) ) +(assert (or (> (+ (* (- 41) x0 ) (* (- 12) x2 ) ) 11) (>= (+ (* 11 x1 ) (* 26 x0 ) (* 11 x1 ) (* 43 x1 ) ) 8) )) +(assert (or (> (+ (* 17 x2 ) (* (- 35) x2 ) ) 49) (not (= (+ (* 2 x0 ) (* 32 x1 ) (* 40 x1 ) (* 1 x0 ) ) (- 6))) (> (+ (* (- 18) x1 ) (* (- 40) x0 ) (* (- 40) x0 ) ) (- 36)) )) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_10.smt2 b/test/regress/regress1/push-pop/fuzz_3_10.smt2 new file mode 100644 index 000000000..389c91573 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_10.smt2 @@ -0,0 +1,22 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (not (<= (+ (* 30 x2 ) (* 34 x2 ) (* 16 x2 ) ) 30)) (not (>= (+ (* (- 7) x1 ) (* 5 x1 ) ) (- 36))) )) +(assert (= (+ (* (- 33) x2 ) (* (- 46) x0 ) (* (- 32) x1 ) ) (- 30)) ) +(assert (or (>= (+ (* (- 35) x1 ) (* (- 29) x1 ) (* 30 x1 ) (* 20 x1 ) ) 27) (> (+ (* 30 x1 ) (* 33 x0 ) ) 16) (= (+ (* (- 28) x2 ) (* 7 x1 ) (* 8 x0 ) ) 37) )) +(assert (or (< (+ (* 6 x2 ) (* (- 12) x1 ) ) (- 14)) (not (<= (+ (* (- 23) x1 ) (* 44 x1 ) ) 9)) (not (<= (+ (* (- 18) x2 ) (* 16 x0 ) (* 47 x0 ) ) 25)) )) +(assert (or (< (+ (* (- 8) x1 ) (* 12 x2 ) (* 23 x1 ) ) (- 50)) (not (> (+ (* 37 x1 ) (* (- 30) x2 ) (* 1 x0 ) (* 13 x1 ) ) (- 22))) )) +(check-sat) +(push 1) +(assert (or (not (= (+ (* (- 3) x0 ) (* (- 49) x1 ) ) 25)) (<= (+ (* 47 x2 ) (* 9 x0 ) ) (- 5)) )) +(assert (or (not (< (+ (* 34 x0 ) (* 28 x0 ) (* 36 x0 ) (* 1 x0 ) ) (- 9))) (>= (+ (* (- 4) x2 ) (* 15 x1 ) (* (- 35) x0 ) (* (- 2) x1 ) ) (- 20)) )) +(assert (not (<= (+ (* (- 4) x1 ) (* 22 x1 ) (* 22 x2 ) (* (- 33) x0 ) ) 12)) ) +(check-sat) +(pop 1) +(assert (<= (+ (* 36 x0 ) (* (- 25) x2 ) (* 48 x2 ) (* (- 14) x1 ) ) (- 9)) ) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_11.smt2 b/test/regress/regress1/push-pop/fuzz_3_11.smt2 new file mode 100644 index 000000000..81fe3b046 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_11.smt2 @@ -0,0 +1,40 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (= (+ (* 25 x1 ) (* (- 35) x1 ) ) 3) (> (+ (* 31 x1 ) (* (- 25) x2 ) (* 24 x1 ) (* (- 37) x2 ) ) 37) )) +(assert (or (= (+ (* (- 18) x1 ) (* (- 42) x0 ) (* (- 41) x2 ) ) 18) (= (+ (* (- 34) x2 ) (* 14 x0 ) (* 33 x0 ) (* (- 40) x2 ) ) (- 34)) )) +(assert (or (>= (+ (* (- 45) x1 ) (* (- 21) x1 ) ) 30) (>= (+ (* 6 x2 ) (* (- 32) x0 ) (* (- 38) x0 ) ) 4) )) +(assert (or (not (< (+ (* (- 39) x2 ) (* (- 47) x2 ) ) 23)) (>= (+ (* 12 x2 ) (* 32 x1 ) (* (- 46) x2 ) ) 13) (not (= (+ (* 48 x2 ) (* 26 x1 ) (* 45 x2 ) ) (- 10))) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* (- 34) x2 ) (* (- 24) x1 ) ) 39)) (<= (+ (* 34 x1 ) (* (- 35) x0 ) (* (- 13) x1 ) (* 2 x2 ) ) (- 2)) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* (- 12) x0 ) (* 37 x1 ) (* (- 30) x0 ) ) (- 43))) (> (+ (* 28 x0 ) (* (- 49) x1 ) ) (- 22)) )) +(check-sat) +(pop 1) +(assert (or (not (>= (+ (* 49 x1 ) (* (- 19) x2 ) ) (- 4))) (not (< (+ (* (- 50) x2 ) (* (- 18) x1 ) ) (- 11))) (not (< (+ (* 43 x0 ) (* 11 x1 ) (* 26 x0 ) (* (- 46) x2 ) ) (- 11))) )) +(assert (or (< (+ (* 38 x0 ) (* (- 19) x1 ) ) (- 31)) (= (+ (* (- 15) x0 ) (* 28 x2 ) (* 9 x2 ) ) (- 43)) )) +(assert (or (>= (+ (* (- 4) x0 ) (* 20 x1 ) (* (- 30) x1 ) (* 17 x0 ) ) (- 13)) (< (+ (* 6 x0 ) (* (- 22) x2 ) (* (- 37) x1 ) (* (- 1) x2 ) ) (- 50)) )) +(assert (or (not (< (+ (* 33 x1 ) (* (- 30) x2 ) (* (- 18) x1 ) ) (- 32))) (> (+ (* 26 x0 ) (* (- 21) x1 ) ) 46) )) +(assert (or (not (<= (+ (* 3 x0 ) (* (- 19) x2 ) (* (- 50) x1 ) (* 31 x2 ) ) 23)) (= (+ (* 46 x0 ) (* 47 x1 ) (* (- 38) x2 ) (* 32 x0 ) ) 30) (<= (+ (* (- 44) x1 ) (* 32 x0 ) (* 29 x1 ) ) 19) )) +(assert (not (= (+ (* (- 21) x1 ) (* (- 4) x0 ) (* 38 x1 ) (* 17 x1 ) ) 35)) ) +(assert (or (<= (+ (* (- 42) x1 ) (* 8 x0 ) (* 37 x1 ) ) (- 33)) (not (> (+ (* 40 x0 ) (* 41 x0 ) (* 4 x1 ) (* (- 17) x2 ) ) 33)) )) +(assert (or (not (<= (+ (* (- 26) x2 ) (* 25 x0 ) (* 42 x0 ) (* 40 x2 ) ) 2)) (> (+ (* (- 33) x2 ) (* 18 x2 ) ) 47) )) +(check-sat) +(push 1) +(assert (or (not (>= (+ (* 13 x2 ) (* (- 16) x2 ) (* (- 18) x0 ) ) (- 15))) (not (< (+ (* 1 x0 ) (* 0 x2 ) (* (- 3) x2 ) (* 43 x0 ) ) 30)) (not (> (+ (* 10 x2 ) (* 36 x1 ) ) (- 17))) )) +(assert (or (not (< (+ (* (- 34) x0 ) (* (- 19) x1 ) (* 31 x0 ) (* 11 x1 ) ) 34)) (= (+ (* (- 45) x2 ) (* 48 x2 ) (* (- 43) x1 ) ) (- 44)) (>= (+ (* 16 x2 ) (* 10 x2 ) (* (- 21) x1 ) ) 23) )) +(check-sat) +(pop 1) +(assert (or (< (+ (* 27 x1 ) (* 6 x2 ) ) 13) (not (<= (+ (* 11 x1 ) (* 19 x0 ) (* (- 41) x0 ) (* (- 29) x1 ) ) (- 6))) (not (= (+ (* (- 16) x2 ) (* (- 8) x1 ) ) 2)) )) +(assert (or (= (+ (* (- 48) x1 ) (* (- 26) x1 ) (* (- 30) x0 ) ) 39) (>= (+ (* 21 x1 ) (* 25 x2 ) (* (- 35) x1 ) ) (- 2)) (= (+ (* (- 4) x1 ) (* 46 x0 ) (* 23 x2 ) ) 38) )) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_12.smt2 b/test/regress/regress1/push-pop/fuzz_3_12.smt2 new file mode 100644 index 000000000..d797c1897 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_12.smt2 @@ -0,0 +1,49 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (> (+ (* (- 45) x0 ) (* 2 x2 ) (* (- 18) x1 ) (* 12 x2 ) ) (- 39))) (not (< (+ (* 12 x1 ) (* (- 34) x2 ) (* (- 6) x2 ) (* (- 11) x1 ) ) 14)) )) +(assert (or (<= (+ (* (- 4) x0 ) (* (- 42) x2 ) (* (- 22) x0 ) ) 15) (not (= (+ (* (- 24) x0 ) (* (- 4) x2 ) ) (- 18))) (>= (+ (* 43 x2 ) (* (- 47) x1 ) (* 22 x0 ) (* 4 x1 ) ) (- 33)) )) +(assert (or (not (<= (+ (* (- 10) x0 ) (* (- 4) x0 ) (* 40 x0 ) ) 47)) (not (= (+ (* 8 x0 ) (* (- 35) x0 ) ) 6)) (not (< (+ (* 13 x1 ) (* (- 1) x2 ) (* 16 x2 ) (* 6 x1 ) ) (- 43))) )) +(assert (or (<= (+ (* 35 x2 ) (* 39 x0 ) (* 25 x1 ) (* 46 x0 ) ) 9) (= (+ (* (- 40) x2 ) (* (- 2) x2 ) (* 17 x2 ) (* (- 48) x1 ) ) 18) )) +(assert (or (> (+ (* (- 47) x2 ) (* (- 24) x2 ) (* (- 25) x0 ) ) 13) (= (+ (* (- 41) x2 ) (* (- 3) x0 ) (* (- 6) x2 ) ) (- 13)) )) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (= (+ (* (- 7) x2 ) (* 6 x0 ) ) (- 1)) ) +(assert (or (> (+ (* 21 x0 ) (* (- 48) x0 ) (* (- 39) x0 ) (* (- 3) x2 ) ) (- 48)) (< (+ (* 12 x2 ) (* 26 x1 ) (* 40 x2 ) ) (- 10)) )) +(check-sat) +(push 1) +(assert (or (= (+ (* (- 23) x2 ) (* 31 x2 ) ) 23) (< (+ (* 26 x0 ) (* 45 x0 ) (* (- 17) x1 ) (* (- 38) x2 ) ) (- 31)) (not (>= (+ (* 21 x1 ) (* (- 12) x2 ) ) (- 38))) )) +(check-sat) +(push 1) +(assert (not (<= (+ (* 26 x1 ) (* (- 40) x1 ) (* 22 x0 ) ) 8)) ) +(assert (or (not (>= (+ (* 20 x0 ) (* 0 x0 ) (* 29 x1 ) ) (- 14))) (< (+ (* 12 x1 ) (* (- 25) x2 ) ) (- 50)) )) +(check-sat) +(pop 1) +(assert (or (= (+ (* 37 x1 ) (* (- 10) x1 ) (* (- 50) x1 ) (* (- 15) x1 ) ) 21) (not (< (+ (* (- 27) x0 ) (* 4 x0 ) ) (- 8))) )) +(assert (or (= (+ (* 0 x1 ) (* (- 43) x0 ) (* 32 x1 ) (* 16 x0 ) ) 11) (not (> (+ (* 20 x2 ) (* (- 11) x2 ) (* (- 14) x0 ) ) (- 43))) (= (+ (* 30 x1 ) (* (- 18) x2 ) (* 0 x1 ) (* (- 32) x0 ) ) (- 5)) )) +(assert (> (+ (* 43 x2 ) (* (- 3) x0 ) ) 4) ) +(assert (> (+ (* 44 x0 ) (* 4 x2 ) ) (- 41)) ) +(check-sat) +(pop 1) +(assert (or (< (+ (* 17 x0 ) (* 11 x0 ) (* 45 x1 ) ) (- 38)) (> (+ (* 49 x1 ) (* (- 9) x2 ) (* 7 x2 ) (* 3 x2 ) ) (- 20)) (not (< (+ (* 10 x2 ) (* 31 x0 ) ) (- 38))) )) +(assert (not (>= (+ (* (- 43) x2 ) (* (- 8) x1 ) (* (- 8) x0 ) ) 34)) ) +(assert (not (>= (+ (* (- 42) x1 ) (* (- 40) x0 ) (* (- 22) x0 ) (* (- 37) x2 ) ) 21)) ) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_3_13.smt2 b/test/regress/regress1/push-pop/fuzz_3_13.smt2 new file mode 100644 index 000000000..2e4b9d2b8 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_13.smt2 @@ -0,0 +1,48 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (<= (+ (* 49 x2 ) (* 24 x0 ) (* (- 41) x0 ) ) 40) (not (>= (+ (* 9 x2 ) (* 2 x1 ) (* 48 x1 ) (* 6 x2 ) ) 48)) )) +(assert (or (not (= (+ (* (- 2) x0 ) (* 22 x0 ) (* (- 37) x0 ) ) 29)) (not (= (+ (* (- 27) x1 ) (* (- 47) x0 ) ) 39)) )) +(assert (or (not (>= (+ (* (- 5) x2 ) (* (- 39) x0 ) (* (- 28) x2 ) ) 47)) (not (= (+ (* (- 25) x2 ) (* (- 1) x0 ) (* (- 26) x2 ) ) (- 35))) (not (<= (+ (* (- 26) x1 ) (* (- 31) x0 ) ) (- 22))) )) +(assert (or (> (+ (* 27 x1 ) (* (- 38) x0 ) (* 43 x2 ) (* (- 13) x0 ) ) 41) (>= (+ (* 34 x2 ) (* 1 x2 ) (* (- 20) x1 ) (* 21 x1 ) ) (- 40)) )) +(assert (> (+ (* (- 28) x1 ) (* 48 x1 ) (* (- 24) x1 ) (* 7 x1 ) ) 41) ) +(check-sat) +(push 1) +(assert (<= (+ (* (- 42) x1 ) (* 25 x0 ) (* (- 47) x2 ) (* 4 x0 ) ) (- 15)) ) +(check-sat) +(push 1) +(assert (or (not (= (+ (* (- 15) x0 ) (* (- 4) x1 ) (* (- 4) x1 ) ) 24)) (not (< (+ (* (- 35) x0 ) (* (- 45) x1 ) (* (- 8) x2 ) (* 19 x2 ) ) 19)) )) +(assert (or (not (< (+ (* (- 39) x1 ) (* 15 x0 ) (* 37 x0 ) ) (- 7))) (<= (+ (* 24 x0 ) (* 20 x0 ) (* 43 x1 ) ) 13) )) +(assert (or (< (+ (* 19 x1 ) (* (- 25) x1 ) ) 8) (> (+ (* 44 x0 ) (* (- 41) x0 ) ) 9) (>= (+ (* 20 x0 ) (* 10 x2 ) (* 23 x0 ) ) 32) )) +(assert (or (>= (+ (* (- 12) x0 ) (* 17 x2 ) ) (- 43)) (not (> (+ (* 25 x1 ) (* (- 38) x2 ) (* (- 10) x0 ) ) 24)) )) +(assert (or (not (< (+ (* (- 50) x2 ) (* 43 x0 ) (* (- 37) x2 ) (* (- 5) x0 ) ) (- 40))) (= (+ (* (- 16) x2 ) (* 6 x2 ) ) (- 11)) (> (+ (* 48 x0 ) (* 29 x1 ) ) 40) )) +(check-sat) +(push 1) +(assert (or (< (+ (* 1 x1 ) (* (- 24) x0 ) (* (- 2) x1 ) ) 21) (not (> (+ (* (- 42) x0 ) (* 40 x0 ) ) (- 33))) )) +(assert (or (not (> (+ (* 23 x0 ) (* (- 14) x2 ) (* (- 23) x0 ) (* (- 37) x0 ) ) 25)) (not (<= (+ (* 12 x2 ) (* 24 x1 ) (* (- 25) x0 ) ) 3)) )) +(check-sat) +(pop 1) +(assert (<= (+ (* 19 x0 ) (* 23 x0 ) (* (- 9) x1 ) (* (- 31) x1 ) ) 27) ) +(assert (or (> (+ (* 33 x1 ) (* (- 24) x1 ) (* (- 48) x2 ) (* (- 42) x1 ) ) 30) (not (<= (+ (* (- 36) x1 ) (* 5 x1 ) ) (- 36))) )) +(assert (or (not (>= (+ (* 20 x1 ) (* 29 x1 ) (* 48 x2 ) ) 40)) (not (> (+ (* (- 26) x2 ) (* 23 x1 ) (* (- 14) x0 ) ) 32)) )) +(assert (>= (+ (* 31 x2 ) (* 43 x1 ) ) 28) ) +(assert (or (= (+ (* 21 x2 ) (* (- 30) x1 ) (* 28 x1 ) (* 43 x0 ) ) 39) (not (<= (+ (* (- 3) x0 ) (* (- 49) x0 ) (* 9 x0 ) (* 24 x2 ) ) 14)) (not (> (+ (* 35 x1 ) (* (- 6) x2 ) (* 37 x0 ) ) 3)) )) +(assert (or (not (<= (+ (* 46 x0 ) (* 11 x1 ) ) 40)) (not (= (+ (* 3 x1 ) (* 49 x1 ) ) (- 38))) )) +(assert (not (<= (+ (* (- 39) x2 ) (* 23 x1 ) ) 5)) ) +(assert (or (not (< (+ (* 44 x1 ) (* (- 23) x1 ) (* 26 x1 ) ) 39)) (> (+ (* 14 x2 ) (* 2 x2 ) (* (- 5) x2 ) ) (- 22)) )) +(assert (not (<= (+ (* (- 15) x2 ) (* 17 x2 ) (* 19 x1 ) ) 30)) ) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_3_14.smt2 b/test/regress/regress1/push-pop/fuzz_3_14.smt2 new file mode 100644 index 000000000..0399bbffa --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_14.smt2 @@ -0,0 +1,34 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (> (+ (* (- 34) x2 ) (* 33 x1 ) (* (- 6) x1 ) (* (- 44) x1 ) ) (- 40)) (not (= (+ (* 7 x0 ) (* (- 27) x2 ) (* 10 x0 ) (* (- 42) x1 ) ) 7)) )) +(assert (or (< (+ (* (- 39) x1 ) (* 32 x1 ) (* 42 x1 ) (* 18 x1 ) ) 26) (not (= (+ (* (- 23) x2 ) (* 17 x1 ) ) (- 39))) )) +(assert (or (>= (+ (* (- 45) x0 ) (* (- 40) x1 ) (* (- 29) x0 ) (* (- 2) x0 ) ) 22) (not (>= (+ (* 11 x1 ) (* (- 42) x1 ) (* (- 21) x0 ) ) 41)) (not (= (+ (* 30 x2 ) (* (- 13) x2 ) (* 21 x1 ) (* (- 16) x2 ) ) 36)) )) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (= (+ (* 20 x2 ) (* 13 x2 ) (* (- 10) x0 ) ) (- 34)) (> (+ (* 23 x1 ) (* 10 x1 ) ) 49) (not (< (+ (* 28 x0 ) (* 22 x2 ) (* 6 x2 ) ) 13)) )) +(assert (or (not (< (+ (* (- 37) x2 ) (* (- 22) x1 ) (* 6 x1 ) ) 18)) (= (+ (* (- 20) x1 ) (* 32 x2 ) (* 16 x1 ) ) (- 49)) )) +(assert (or (>= (+ (* (- 2) x2 ) (* (- 23) x1 ) (* 39 x2 ) (* 35 x2 ) ) (- 8)) (not (<= (+ (* (- 19) x2 ) (* (- 43) x2 ) (* 22 x1 ) (* (- 27) x1 ) ) (- 48))) (not (= (+ (* (- 44) x1 ) (* 39 x1 ) (* 28 x2 ) ) (- 35))) )) +(assert (or (not (<= (+ (* (- 47) x1 ) (* (- 22) x2 ) (* 43 x2 ) ) (- 5))) (not (>= (+ (* (- 45) x2 ) (* (- 35) x2 ) (* 44 x0 ) ) (- 14))) )) +(assert (or (not (>= (+ (* (- 7) x1 ) (* (- 24) x2 ) (* 49 x1 ) ) (- 27))) (< (+ (* 48 x1 ) (* 19 x0 ) ) (- 6)) (not (< (+ (* 39 x0 ) (* 48 x1 ) ) 7)) )) +(assert (or (<= (+ (* (- 11) x2 ) (* 29 x0 ) ) (- 16)) (not (< (+ (* 31 x1 ) (* 5 x2 ) ) 44)) (>= (+ (* 0 x1 ) (* 42 x2 ) (* 27 x1 ) ) (- 17)) )) +(assert (not (< (+ (* 49 x1 ) (* 1 x0 ) ) 40)) ) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* 40 x2 ) (* (- 42) x1 ) (* 1 x0 ) (* 0 x0 ) ) 24)) (not (> (+ (* (- 27) x0 ) (* 46 x1 ) (* (- 48) x0 ) (* 29 x0 ) ) 11)) )) +(check-sat) +(pop 1) +(assert (not (< (+ (* 16 x1 ) (* (- 26) x0 ) (* (- 6) x0 ) ) 34)) ) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_15.smt2 b/test/regress/regress1/push-pop/fuzz_3_15.smt2 new file mode 100644 index 000000000..2a8ffe0fa --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_15.smt2 @@ -0,0 +1,35 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (not (<= (+ (* (- 3) x0 ) (* 38 x0 ) (* 34 x1 ) ) (- 5))) ) +(assert (or (not (> (+ (* (- 27) x0 ) (* 26 x1 ) ) (- 50))) (not (>= (+ (* 32 x0 ) (* 10 x0 ) (* (- 43) x1 ) (* (- 39) x0 ) ) (- 36))) )) +(check-sat) +(push 1) +(assert (> (+ (* (- 23) x2 ) (* 49 x2 ) ) 14) ) +(assert (not (= (+ (* 20 x1 ) (* (- 38) x2 ) ) 33)) ) +(assert (not (<= (+ (* 30 x0 ) (* (- 13) x1 ) (* 21 x1 ) ) 20)) ) +(assert (or (<= (+ (* 48 x0 ) (* (- 42) x0 ) (* 34 x1 ) (* 47 x1 ) ) 12) (not (>= (+ (* 0 x1 ) (* (- 1) x1 ) (* (- 19) x1 ) ) 40)) (not (>= (+ (* (- 40) x2 ) (* 3 x2 ) (* 4 x0 ) (* 19 x2 ) ) 34)) )) +(assert (or (= (+ (* (- 7) x1 ) (* 15 x0 ) (* (- 12) x0 ) ) 6) (not (<= (+ (* (- 41) x2 ) (* 10 x0 ) (* 12 x2 ) ) 49)) )) +(assert (or (<= (+ (* 12 x2 ) (* (- 50) x1 ) ) (- 25)) (= (+ (* (- 29) x2 ) (* (- 11) x2 ) (* (- 8) x2 ) (* (- 3) x2 ) ) (- 39)) )) +(assert (or (= (+ (* 33 x2 ) (* 44 x0 ) (* (- 4) x1 ) ) 5) (not (< (+ (* 27 x2 ) (* (- 45) x0 ) (* 43 x2 ) (* 40 x0 ) ) 17)) (not (<= (+ (* (- 40) x2 ) (* 3 x0 ) (* 16 x2 ) (* (- 37) x1 ) ) 29)) )) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (= (+ (* (- 21) x0 ) (* 5 x2 ) ) (- 27)) (not (<= (+ (* (- 20) x0 ) (* 19 x0 ) (* (- 50) x1 ) (* (- 24) x0 ) ) (- 32))) )) +(check-sat) +(pop 1) +(assert (not (<= (+ (* 9 x2 ) (* 0 x0 ) (* (- 40) x0 ) (* 49 x2 ) ) (- 11))) ) +(assert (or (not (< (+ (* (- 2) x0 ) (* 2 x2 ) ) 19)) (= (+ (* (- 28) x1 ) (* (- 1) x2 ) (* (- 4) x1 ) ) 38) )) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_3_2.smt2 b/test/regress/regress1/push-pop/fuzz_3_2.smt2 new file mode 100644 index 000000000..cbff796c6 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_2.smt2 @@ -0,0 +1,34 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (not (>= (+ (* 47 x0 ) (* (- 1) x2 ) (* 13 x2 ) ) (- 9))) (not (< (+ (* 23 x1 ) (* (- 50) x0 ) (* 35 x1 ) (* 12 x2 ) ) 14)) )) +(assert (or (not (<= (+ (* 3 x0 ) (* (- 15) x2 ) (* 34 x0 ) ) (- 39))) (not (> (+ (* (- 35) x0 ) (* 36 x2 ) (* (- 3) x1 ) ) 22)) (not (> (+ (* 46 x2 ) (* 2 x2 ) (* (- 33) x1 ) (* (- 24) x0 ) ) (- 39))) )) +(assert (or (<= (+ (* 27 x1 ) (* 18 x2 ) (* (- 3) x2 ) ) (- 2)) (= (+ (* 27 x0 ) (* (- 26) x2 ) (* 15 x2 ) (* 23 x0 ) ) 11) )) +(assert (or (= (+ (* 23 x1 ) (* (- 1) x1 ) (* (- 3) x2 ) (* 49 x1 ) ) (- 26)) (not (> (+ (* (- 30) x0 ) (* (- 1) x0 ) (* 15 x1 ) ) (- 23))) )) +(check-sat) +(push 1) +(assert (or (not (= (+ (* 24 x1 ) (* 5 x2 ) (* (- 18) x1 ) (* (- 40) x2 ) ) (- 6))) (not (< (+ (* 6 x0 ) (* (- 29) x0 ) (* 16 x2 ) ) (- 42))) )) +(assert (or (= (+ (* (- 33) x0 ) (* 40 x0 ) (* (- 28) x1 ) (* (- 29) x0 ) ) (- 1)) (<= (+ (* (- 17) x1 ) (* 0 x0 ) (* 2 x1 ) ) (- 8)) (not (= (+ (* 39 x2 ) (* 4 x0 ) (* 12 x1 ) (* (- 1) x2 ) ) (- 40))) )) +(check-sat) +(push 1) +(assert (not (<= (+ (* 24 x2 ) (* 9 x2 ) (* 38 x0 ) (* 9 x2 ) ) (- 12))) ) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (> (+ (* (- 33) x1 ) (* 1 x0 ) (* (- 27) x1 ) (* (- 39) x1 ) ) 30)) ) +(check-sat) +(pop 1) +(assert (not (>= (+ (* (- 36) x1 ) (* 34 x0 ) (* 39 x0 ) (* 2 x2 ) ) 16)) ) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_3.smt2 b/test/regress/regress1/push-pop/fuzz_3_3.smt2 new file mode 100644 index 000000000..ec072821c --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_3.smt2 @@ -0,0 +1,27 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (= (+ (* (- 47) x1 ) (* 42 x2 ) ) (- 13)) (< (+ (* 5 x2 ) (* 8 x2 ) ) 41) (not (= (+ (* (- 20) x2 ) (* (- 3) x2 ) (* 38 x1 ) (* (- 38) x0 ) ) (- 30))) )) +(assert (or (= (+ (* (- 23) x2 ) (* 29 x2 ) ) (- 30)) (not (>= (+ (* 46 x1 ) (* (- 49) x0 ) (* (- 17) x0 ) (* 17 x0 ) ) 2)) (not (<= (+ (* (- 32) x0 ) (* 23 x0 ) (* (- 5) x1 ) (* (- 50) x2 ) ) (- 46))) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* 36 x2 ) (* 21 x2 ) ) (- 31))) (not (= (+ (* 48 x2 ) (* (- 2) x1 ) (* 32 x0 ) ) 48)) (> (+ (* (- 43) x0 ) (* 7 x2 ) (* 1 x1 ) (* 2 x1 ) ) 15) )) +(assert (or (not (<= (+ (* (- 27) x1 ) (* 4 x0 ) (* 43 x2 ) ) (- 23))) (not (> (+ (* (- 4) x1 ) (* 31 x2 ) (* 22 x2 ) ) 0)) )) +(assert (or (not (<= (+ (* 19 x0 ) (* (- 29) x0 ) (* 18 x2 ) (* 6 x0 ) ) 24)) (>= (+ (* 32 x2 ) (* 36 x1 ) (* 41 x1 ) ) 44) )) +(assert (> (+ (* 30 x0 ) (* (- 9) x2 ) (* (- 22) x0 ) ) 38) ) +(assert (or (>= (+ (* (- 19) x0 ) (* 32 x2 ) (* (- 48) x2 ) ) (- 14)) (>= (+ (* (- 49) x2 ) (* 29 x2 ) (* 15 x1 ) ) (- 34)) )) +(assert (or (not (< (+ (* (- 6) x0 ) (* (- 43) x1 ) ) 35)) (= (+ (* (- 48) x2 ) (* (- 31) x0 ) ) 34) (not (< (+ (* (- 41) x0 ) (* 45 x2 ) (* (- 17) x1 ) (* (- 38) x2 ) ) 1)) )) +(assert (or (not (<= (+ (* (- 10) x2 ) (* 45 x1 ) ) 49)) (not (<= (+ (* 38 x2 ) (* 17 x2 ) (* (- 18) x1 ) (* (- 17) x1 ) ) 3)) )) +(assert (not (= (+ (* 20 x1 ) (* (- 3) x2 ) (* 15 x1 ) ) (- 11))) ) +(check-sat) +(push 1) +(assert (not (<= (+ (* (- 24) x1 ) (* 47 x2 ) (* (- 32) x2 ) ) (- 34))) ) +(check-sat) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_4.smt2 b/test/regress/regress1/push-pop/fuzz_3_4.smt2 new file mode 100644 index 000000000..93be94865 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_4.smt2 @@ -0,0 +1,35 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (< (+ (* (- 15) x0 ) (* (- 4) x0 ) (* (- 33) x2 ) ) (- 21)) (<= (+ (* (- 2) x1 ) (* 12 x1 ) (* 48 x1 ) ) (- 21)) (> (+ (* 43 x2 ) (* (- 6) x2 ) ) (- 26)) )) +(assert (not (<= (+ (* (- 9) x2 ) (* 28 x0 ) (* (- 26) x0 ) ) (- 2))) ) +(assert (or (= (+ (* (- 43) x0 ) (* 49 x1 ) (* (- 49) x0 ) ) 25) (not (= (+ (* 39 x0 ) (* (- 23) x2 ) ) (- 12))) )) +(assert (or (not (<= (+ (* 13 x1 ) (* (- 17) x1 ) (* (- 27) x0 ) (* (- 24) x0 ) ) (- 47))) (not (<= (+ (* 5 x1 ) (* (- 31) x1 ) (* (- 40) x2 ) ) 28)) )) +(assert (or (not (< (+ (* (- 7) x2 ) (* (- 24) x0 ) (* 42 x0 ) ) (- 27))) (not (< (+ (* (- 4) x2 ) (* (- 16) x0 ) (* (- 20) x2 ) ) (- 14))) (not (<= (+ (* 2 x2 ) (* 26 x1 ) ) 12)) )) +(assert (< (+ (* (- 9) x0 ) (* 45 x1 ) (* (- 12) x2 ) ) 37) ) +(assert (or (= (+ (* 23 x2 ) (* 15 x1 ) (* 32 x1 ) (* (- 30) x2 ) ) 30) (>= (+ (* 36 x1 ) (* (- 36) x0 ) (* (- 22) x2 ) (* 36 x1 ) ) 20) )) +(assert (or (not (< (+ (* (- 22) x2 ) (* 34 x0 ) ) (- 10))) (not (>= (+ (* (- 38) x2 ) (* (- 46) x2 ) ) 34)) (not (>= (+ (* 24 x0 ) (* (- 48) x1 ) (* 7 x0 ) ) (- 19))) )) +(assert (<= (+ (* (- 49) x2 ) (* (- 18) x0 ) (* 17 x0 ) ) 18) ) +(assert (or (not (<= (+ (* (- 16) x2 ) (* 24 x1 ) (* (- 38) x2 ) ) 33)) (<= (+ (* 29 x2 ) (* (- 22) x1 ) ) (- 19)) )) +(assert (or (< (+ (* 19 x1 ) (* (- 30) x0 ) ) 39) (= (+ (* (- 47) x0 ) (* 46 x1 ) (* 37 x0 ) ) (- 28)) (not (= (+ (* (- 12) x0 ) (* 19 x0 ) ) 19)) )) +(assert (or (not (> (+ (* 35 x1 ) (* 35 x0 ) (* 17 x1 ) (* 46 x2 ) ) 46)) (not (>= (+ (* (- 8) x0 ) (* 43 x1 ) (* (- 26) x2 ) ) 21)) (not (< (+ (* (- 29) x1 ) (* (- 10) x2 ) (* (- 35) x1 ) ) 42)) )) +(check-sat) +(push 1) +(assert (or (>= (+ (* 21 x2 ) (* (- 38) x1 ) (* (- 21) x2 ) ) 28) (= (+ (* 28 x1 ) (* 2 x1 ) (* (- 16) x2 ) (* 47 x0 ) ) (- 45)) )) +(assert (not (= (+ (* 33 x0 ) (* 26 x0 ) (* 33 x1 ) (* (- 41) x2 ) ) 4)) ) +(assert (or (= (+ (* 40 x1 ) (* (- 23) x1 ) (* 27 x0 ) ) (- 19)) (>= (+ (* (- 29) x0 ) (* (- 12) x0 ) (* 42 x0 ) ) (- 30)) )) +(assert (or (not (<= (+ (* 35 x0 ) (* 40 x2 ) (* (- 46) x0 ) ) (- 35))) (>= (+ (* 34 x0 ) (* 33 x0 ) (* 27 x0 ) (* (- 21) x1 ) ) (- 4)) )) +(assert (not (<= (+ (* 42 x1 ) (* (- 4) x1 ) (* (- 30) x0 ) (* (- 23) x0 ) ) (- 44))) ) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (>= (+ (* 3 x1 ) (* 41 x2 ) (* (- 28) x1 ) ) (- 49))) ) +(assert (or (not (<= (+ (* (- 29) x1 ) (* (- 5) x2 ) (* 15 x2 ) (* (- 26) x1 ) ) (- 14))) (>= (+ (* (- 47) x1 ) (* (- 31) x1 ) ) 46) )) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_5.smt2 b/test/regress/regress1/push-pop/fuzz_3_5.smt2 new file mode 100644 index 000000000..fd9204081 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_5.smt2 @@ -0,0 +1,37 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (< (+ (* 23 x1 ) (* (- 27) x1 ) (* 22 x0 ) ) (- 22)) ) +(assert (>= (+ (* (- 4) x0 ) (* (- 9) x1 ) (* (- 40) x0 ) (* 40 x2 ) ) (- 27)) ) +(assert (or (not (>= (+ (* (- 34) x0 ) (* (- 36) x1 ) ) (- 26))) (not (>= (+ (* 6 x2 ) (* (- 6) x1 ) ) (- 43))) )) +(assert (or (>= (+ (* 20 x2 ) (* 12 x0 ) (* (- 50) x1 ) ) (- 46)) (not (> (+ (* 11 x1 ) (* (- 30) x0 ) ) (- 21))) )) +(check-sat) +(push 1) +(assert (or (not (>= (+ (* (- 17) x2 ) (* 25 x1 ) (* 43 x0 ) (* (- 9) x0 ) ) (- 19))) (> (+ (* 4 x1 ) (* (- 22) x1 ) ) 8) (> (+ (* 19 x1 ) (* (- 1) x1 ) (* (- 22) x1 ) (* (- 47) x2 ) ) 46) )) +(assert (or (> (+ (* (- 12) x1 ) (* 25 x1 ) ) (- 18)) (not (= (+ (* (- 47) x0 ) (* (- 13) x2 ) (* (- 13) x1 ) (* (- 10) x0 ) ) (- 27))) )) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (>= (+ (* 9 x2 ) (* (- 18) x1 ) (* (- 7) x0 ) (* (- 2) x2 ) ) (- 40))) (< (+ (* 2 x1 ) (* (- 4) x1 ) (* (- 48) x2 ) ) 32) )) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (<= (+ (* (- 10) x2 ) (* (- 20) x1 ) (* 9 x2 ) ) 23)) ) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_3_6.smt2 b/test/regress/regress1/push-pop/fuzz_3_6.smt2 new file mode 100644 index 000000000..1901016c2 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_6.smt2 @@ -0,0 +1,36 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (= (+ (* 40 x1 ) (* (- 35) x0 ) (* 10 x1 ) ) 4) (not (= (+ (* 38 x1 ) (* 40 x1 ) (* (- 28) x2 ) ) 44)) (< (+ (* (- 46) x1 ) (* (- 18) x0 ) ) 37) )) +(assert (or (<= (+ (* (- 4) x2 ) (* (- 29) x1 ) ) (- 37)) (not (> (+ (* (- 10) x2 ) (* 13 x0 ) ) (- 21))) )) +(check-sat) +(push 1) +(assert (or (> (+ (* 21 x0 ) (* 13 x2 ) ) 49) (>= (+ (* 19 x2 ) (* 45 x2 ) (* 9 x1 ) ) (- 45)) )) +(assert (or (= (+ (* (- 17) x0 ) (* 22 x0 ) ) 12) (<= (+ (* 28 x1 ) (* 27 x0 ) (* 39 x0 ) (* (- 49) x2 ) ) (- 9)) )) +(assert (or (not (<= (+ (* (- 49) x2 ) (* (- 28) x1 ) (* 24 x2 ) ) 47)) (>= (+ (* 13 x2 ) (* 49 x0 ) (* (- 45) x0 ) (* (- 44) x1 ) ) (- 14)) )) +(assert (or (> (+ (* 9 x1 ) (* 18 x2 ) ) 31) (not (<= (+ (* 10 x2 ) (* 49 x1 ) (* (- 29) x2 ) (* (- 45) x2 ) ) (- 22))) )) +(assert (not (<= (+ (* 49 x0 ) (* (- 50) x0 ) (* 0 x1 ) ) 40)) ) +(assert (or (> (+ (* 37 x1 ) (* (- 37) x2 ) ) (- 13)) (not (< (+ (* (- 38) x2 ) (* (- 15) x2 ) (* (- 39) x2 ) (* (- 13) x1 ) ) 20)) (>= (+ (* 8 x2 ) (* 47 x1 ) (* (- 21) x2 ) (* 41 x0 ) ) 13) )) +(assert (or (> (+ (* (- 26) x2 ) (* 9 x0 ) (* (- 47) x1 ) (* (- 30) x0 ) ) (- 12)) (not (>= (+ (* 3 x0 ) (* 24 x0 ) ) (- 10))) )) +(check-sat) +(push 1) +(assert (or (= (+ (* (- 27) x1 ) (* 34 x2 ) (* (- 14) x2 ) (* (- 24) x1 ) ) (- 38)) (<= (+ (* (- 41) x2 ) (* 36 x1 ) (* (- 44) x2 ) (* (- 19) x2 ) ) 9) )) +(assert (or (not (<= (+ (* (- 2) x1 ) (* (- 7) x1 ) ) 45)) (<= (+ (* (- 39) x0 ) (* (- 18) x2 ) ) (- 13)) )) +(assert (or (= (+ (* (- 32) x2 ) (* 37 x2 ) ) (- 26)) (< (+ (* 26 x0 ) (* 4 x1 ) ) (- 32)) )) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (< (+ (* (- 23) x2 ) (* (- 14) x2 ) (* 3 x1 ) ) (- 39)) (not (> (+ (* 48 x1 ) (* 14 x0 ) ) (- 32))) (>= (+ (* (- 10) x0 ) (* (- 46) x0 ) ) 12) )) +(check-sat) +(pop 1) +(assert (< (+ (* (- 41) x1 ) (* (- 42) x1 ) (* 41 x1 ) ) (- 36)) ) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_3_7.smt2 b/test/regress/regress1/push-pop/fuzz_3_7.smt2 new file mode 100644 index 000000000..c3b8aadc7 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_7.smt2 @@ -0,0 +1,36 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(check-sat) +(push 1) +(assert (or (not (>= (+ (* 25 x1 ) (* (- 37) x2 ) (* (- 48) x1 ) ) (- 37))) (not (<= (+ (* (- 6) x1 ) (* 0 x2 ) (* 22 x1 ) ) (- 25))) )) +(assert (or (not (> (+ (* 25 x2 ) (* (- 14) x1 ) ) (- 40))) (not (> (+ (* (- 44) x1 ) (* (- 5) x0 ) ) (- 31))) )) +(assert (or (< (+ (* (- 31) x2 ) (* (- 42) x1 ) (* (- 7) x0 ) (* (- 4) x2 ) ) 18) (<= (+ (* 8 x1 ) (* (- 46) x2 ) ) (- 4)) )) +(check-sat) +(push 1) +(assert (or (> (+ (* (- 45) x1 ) (* 45 x0 ) (* (- 12) x0 ) (* (- 24) x2 ) ) (- 41)) (< (+ (* 17 x2 ) (* 38 x0 ) (* 16 x2 ) ) 40) )) +(assert (or (< (+ (* 14 x2 ) (* 45 x0 ) (* (- 13) x0 ) (* (- 40) x0 ) ) 44) (= (+ (* (- 28) x1 ) (* (- 34) x1 ) (* (- 1) x0 ) ) 49) )) +(assert (or (>= (+ (* 2 x0 ) (* 21 x2 ) ) 21) (< (+ (* (- 5) x2 ) (* 41 x1 ) (* (- 16) x1 ) ) 3) )) +(assert (= (+ (* (- 17) x2 ) (* 34 x1 ) (* (- 20) x0 ) (* (- 47) x2 ) ) (- 39)) ) +(check-sat) +(push 1) +(assert (or (< (+ (* 26 x2 ) (* (- 29) x2 ) (* 3 x2 ) (* (- 42) x0 ) ) (- 10)) (not (<= (+ (* 9 x0 ) (* (- 31) x1 ) ) (- 6))) )) +(assert (or (not (< (+ (* (- 15) x0 ) (* (- 44) x1 ) (* (- 5) x2 ) (* 25 x2 ) ) 38)) (= (+ (* (- 24) x1 ) (* 20 x0 ) (* 8 x0 ) ) (- 10)) (not (> (+ (* (- 35) x1 ) (* (- 14) x2 ) ) 6)) )) +(assert (or (> (+ (* (- 13) x0 ) (* 10 x2 ) ) (- 16)) (= (+ (* 38 x0 ) (* 38 x2 ) (* 3 x0 ) ) 8) (not (<= (+ (* 18 x1 ) (* (- 26) x0 ) ) (- 14))) )) +(check-sat) +(push 1) +(assert (or (< (+ (* (- 11) x1 ) (* 42 x1 ) ) (- 50)) (not (> (+ (* (- 24) x0 ) (* 8 x1 ) (* 44 x2 ) (* 27 x0 ) ) 48)) (< (+ (* 2 x0 ) (* 32 x2 ) ) (- 30)) )) +(assert (>= (+ (* 28 x2 ) (* 29 x1 ) (* (- 7) x2 ) (* 16 x0 ) ) (- 19)) ) +(check-sat) +(pop 1) +(assert (or (not (> (+ (* 1 x1 ) (* (- 33) x1 ) (* (- 2) x1 ) ) (- 29))) (>= (+ (* 7 x2 ) (* 4 x0 ) (* 49 x2 ) ) (- 17)) )) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_3_8.smt2 b/test/regress/regress1/push-pop/fuzz_3_8.smt2 new file mode 100644 index 000000000..cebf4d3e6 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_8.smt2 @@ -0,0 +1,47 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (not (> (+ (* (- 25) x0 ) (* 16 x2 ) ) 21)) (>= (+ (* 18 x1 ) (* (- 35) x0 ) (* 18 x0 ) (* 24 x0 ) ) (- 50)) )) +(assert (> (+ (* (- 40) x0 ) (* 29 x2 ) ) 9) ) +(check-sat) +(push 1) +(assert (or (not (> (+ (* 32 x1 ) (* (- 23) x0 ) (* 46 x2 ) ) 11)) (not (< (+ (* (- 12) x0 ) (* (- 40) x0 ) (* 43 x2 ) (* (- 13) x1 ) ) 49)) )) +(assert (not (>= (+ (* (- 47) x0 ) (* 24 x1 ) ) 32)) ) +(check-sat) +(pop 1) +(assert (or (= (+ (* 8 x0 ) (* 31 x1 ) (* 38 x1 ) ) (- 31)) (<= (+ (* (- 16) x1 ) (* (- 22) x2 ) (* 27 x2 ) (* (- 23) x0 ) ) (- 12)) )) +(assert (or (not (>= (+ (* 43 x1 ) (* (- 29) x1 ) (* 32 x0 ) (* (- 29) x1 ) ) (- 10))) (>= (+ (* 24 x0 ) (* (- 31) x1 ) ) 34) )) +(assert (or (not (>= (+ (* (- 39) x2 ) (* (- 48) x2 ) (* (- 46) x0 ) (* 2 x1 ) ) 19)) (not (<= (+ (* (- 44) x0 ) (* (- 36) x2 ) ) (- 23))) )) +(check-sat) +(push 1) +(assert (not (<= (+ (* 37 x1 ) (* 19 x2 ) (* 24 x1 ) (* (- 15) x0 ) ) (- 12))) ) +(assert (or (>= (+ (* (- 24) x0 ) (* (- 29) x0 ) (* 40 x2 ) ) (- 39)) (not (<= (+ (* (- 41) x0 ) (* 40 x2 ) (* 41 x1 ) (* (- 3) x0 ) ) 28)) )) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (> (+ (* 38 x0 ) (* (- 47) x0 ) (* 19 x0 ) (* 40 x2 ) ) (- 39))) (not (< (+ (* 30 x2 ) (* 39 x1 ) ) (- 28))) )) +(assert (or (>= (+ (* (- 12) x0 ) (* (- 26) x1 ) (* (- 13) x1 ) ) 28) (> (+ (* (- 10) x0 ) (* (- 32) x1 ) ) 12) )) +(check-sat) +(push 1) +(assert (< (+ (* (- 33) x2 ) (* (- 13) x0 ) ) 42) ) +(assert (or (not (= (+ (* 17 x2 ) (* 4 x2 ) ) 7)) (<= (+ (* 19 x1 ) (* 22 x1 ) (* 19 x1 ) ) 26) (not (<= (+ (* 9 x2 ) (* 0 x0 ) (* 24 x2 ) ) (- 10))) )) +(assert (< (+ (* 45 x1 ) (* (- 38) x0 ) (* 19 x2 ) (* 17 x1 ) ) (- 14)) ) +(check-sat) +(pop 1) +(assert (not (< (+ (* 10 x0 ) (* (- 31) x2 ) (* (- 21) x0 ) ) (- 29))) ) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_3_9.smt2 b/test/regress/regress1/push-pop/fuzz_3_9.smt2 new file mode 100644 index 000000000..96aaf9f51 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_3_9.smt2 @@ -0,0 +1,52 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(assert (or (not (>= (+ (* (- 32) x2 ) (* (- 10) x0 ) (* (- 33) x0 ) (* 16 x1 ) ) (- 35))) (< (+ (* (- 46) x1 ) (* 44 x1 ) (* (- 15) x1 ) (* (- 22) x2 ) ) (- 20)) )) +(check-sat) +(push 1) +(assert (or (not (< (+ (* (- 1) x2 ) (* (- 26) x0 ) ) 32)) (> (+ (* 39 x1 ) (* 31 x1 ) (* (- 16) x0 ) ) 27) )) +(check-sat) +(pop 1) +(assert (or (> (+ (* 46 x1 ) (* 48 x1 ) (* 26 x0 ) ) 12) (= (+ (* 30 x1 ) (* 1 x0 ) (* 8 x2 ) (* 11 x2 ) ) (- 3)) )) +(assert (<= (+ (* (- 11) x1 ) (* (- 27) x2 ) (* (- 29) x2 ) (* 23 x1 ) ) 19) ) +(assert (not (> (+ (* 15 x0 ) (* 25 x1 ) ) 47)) ) +(assert (<= (+ (* (- 3) x2 ) (* 1 x1 ) (* 36 x1 ) ) (- 27)) ) +(check-sat) +(push 1) +(assert (not (<= (+ (* (- 3) x0 ) (* (- 33) x2 ) (* 7 x2 ) (* (- 37) x0 ) ) 13)) ) +(check-sat) +(pop 1) +(assert (or (not (> (+ (* 24 x2 ) (* (- 48) x0 ) (* 18 x1 ) ) (- 46))) (not (< (+ (* (- 31) x1 ) (* 18 x0 ) (* (- 32) x0 ) (* (- 9) x0 ) ) 37)) )) +(assert (or (not (< (+ (* (- 30) x2 ) (* (- 32) x0 ) (* 27 x0 ) ) 28)) (not (= (+ (* (- 20) x2 ) (* (- 10) x2 ) ) (- 3))) (<= (+ (* 42 x0 ) (* 49 x0 ) (* 28 x0 ) (* 0 x2 ) ) (- 30)) )) +(assert (or (not (<= (+ (* 15 x2 ) (* 22 x2 ) ) (- 7))) (< (+ (* (- 7) x1 ) (* (- 42) x0 ) (* (- 27) x2 ) (* 19 x2 ) ) 15) (< (+ (* (- 25) x1 ) (* 39 x2 ) (* (- 24) x1 ) (* 17 x1 ) ) (- 48)) )) +(assert (or (= (+ (* (- 49) x0 ) (* 27 x1 ) (* 16 x0 ) (* (- 26) x2 ) ) (- 24)) (<= (+ (* (- 33) x0 ) (* (- 7) x1 ) (* (- 7) x2 ) (* 1 x0 ) ) 34) )) +(assert (not (<= (+ (* 30 x0 ) (* 17 x0 ) (* (- 48) x0 ) ) 19)) ) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (= (+ (* 24 x2 ) (* 13 x2 ) (* (- 13) x0 ) (* 14 x2 ) ) 8)) (> (+ (* (- 30) x2 ) (* (- 32) x1 ) (* (- 45) x0 ) (* (- 2) x2 ) ) 15) )) +(assert (or (> (+ (* (- 9) x0 ) (* (- 21) x1 ) ) 3) (not (= (+ (* (- 26) x2 ) (* 3 x0 ) ) (- 10))) )) +(assert (or (not (> (+ (* (- 20) x0 ) (* 43 x0 ) ) (- 14))) (> (+ (* 13 x1 ) (* (- 38) x1 ) (* 4 x1 ) (* (- 12) x2 ) ) (- 15)) (not (< (+ (* (- 38) x2 ) (* (- 3) x0 ) ) 15)) )) +(assert (or (>= (+ (* (- 33) x0 ) (* 8 x1 ) (* 16 x0 ) ) 32) (not (<= (+ (* 23 x0 ) (* (- 28) x0 ) (* 30 x1 ) (* 17 x2 ) ) 41)) (>= (+ (* 28 x1 ) (* (- 42) x0 ) ) (- 12)) )) +(assert (or (not (<= (+ (* 23 x1 ) (* 20 x2 ) (* (- 34) x0 ) (* (- 40) x2 ) ) 28)) (not (= (+ (* 17 x2 ) (* 30 x2 ) ) (- 15))) (<= (+ (* (- 47) x1 ) (* (- 24) x0 ) (* (- 37) x0 ) ) 19) )) +(assert (or (= (+ (* 14 x0 ) (* (- 22) x1 ) ) 30) (<= (+ (* 28 x1 ) (* 33 x2 ) (* 49 x2 ) ) (- 35)) (<= (+ (* (- 47) x0 ) (* (- 45) x2 ) (* (- 7) x1 ) (* (- 47) x1 ) ) 47) )) +(check-sat) +(push 1) +(assert (or (not (> (+ (* 35 x2 ) (* (- 46) x0 ) ) 26)) (>= (+ (* 3 x1 ) (* 1 x2 ) (* (- 14) x0 ) ) 27) (> (+ (* (- 27) x2 ) (* 20 x2 ) (* 19 x1 ) (* 23 x2 ) ) 39) )) +(assert (or (not (> (+ (* 20 x0 ) (* 9 x2 ) ) 6)) (not (< (+ (* 19 x1 ) (* (- 45) x1 ) ) (- 45))) )) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_4.smt2 b/test/regress/regress1/push-pop/fuzz_4.smt2 new file mode 100644 index 000000000..db191f610 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_4.smt2 @@ -0,0 +1,58 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(assert (or (and (not (or (or (or (and (or (and (and x7 x2) (or x6 x4)) (not (not x3))) (or (not (or x1 x2)) (and (or x1 x1) (and x5 x5)))) (or (and (and (or x2 x5) (and x6 x6)) (not (and x5 x6))) (and (and (and x5 x5) (or x1 x6)) (or (or x0 x3) (and x2 x4))))) (not (and (and (or (and x4 x4) (and x2 x4)) (or (and x0 x6) (or x6 x5))) (not (or (and x6 x7) (or x4 x4)))))) (and (not (or (or (or (not x6) (and x5 x6)) (or (and x2 x4) (or x6 x7))) (or (or (or x2 x5) (and x3 x6)) (or (and x5 x1) (and x1 x6))))) (and (not (and (and (not x1) (and x1 x7)) (and (or x2 x6) (or x0 x5)))) (and (not (and (not x4) (or x0 x2))) (and (not (and x4 x0)) (not (and x4 x1)))))))) (or (not (not (or (and (or (or (and x2 x7) (not x1)) (not (or x3 x7))) (and (not (not x4)) (or (or x7 x2) (and x3 x2)))) (or (or (and (or x2 x5) (or x0 x4)) (or (not x5) (not x5))) (and (not (and x0 x2)) (or (and x2 x7) (not x2))))))) (not (or (and (or (or (not (not x2)) (or (or x5 x2) (or x5 x7))) (and (and (or x0 x1) (or x7 x6)) (not (and x3 x0)))) (and (and (or (or x7 x5) (not x7)) (and (and x4 x5) (or x7 x2))) (or (or (not x1) (not x3)) (or (or x4 x7) (and x2 x0))))) (or (or (or (and (or x4 x6) (not x2)) (not (and x4 x4))) (not (or (and x2 x3) (not x1)))) (and (and (not (or x6 x3)) (not (or x4 x4))) (not (and (not x7) (and x2 x3))))))))) (or (not (or (or (and (and (not (or (and x0 x5) (and x7 x6))) (or (or (not x0) (not x3)) (or (and x0 x6) (or x7 x0)))) (or (or (and (not x4) (or x2 x3)) (not (not x7))) (not (and (and x2 x6) (not x0))))) (not (or (or (or (and x4 x2) (not x4)) (or (not x3) (and x5 x2))) (or (or (not x7) (not x1)) (not (and x1 x0)))))) (and (or (or (or (or (not x6) (and x3 x6)) (not (and x1 x0))) (or (or (and x7 x3) (not x1)) (not (or x7 x7)))) (and (or (or (not x1) (and x4 x2)) (or (not x3) (not x0))) (or (or (not x1) (not x7)) (not (or x1 x5))))) (or (or (and (and (not x0) (not x3)) (or (and x5 x4) (and x6 x0))) (or (or (and x4 x1) (and x7 x4)) (and (or x6 x0) (not x3)))) (not (and (or (not x4) (not x3)) (and (not x7) (not x7)))))))) (and (or (not (and (not (not (or (and x2 x6) (or x1 x2)))) (and (not (or (or x2 x4) (or x0 x4))) (or (or (and x2 x1) (and x1 x4)) (not (and x3 x0)))))) (and (not (not (and (and (not x3) (not x2)) (not (or x4 x6))))) (and (or (and (not (not x6)) (not (not x0))) (not (not (not x7)))) (and (not (not (and x6 x5))) (not (and (not x2) (or x5 x3))))))) (not (or (and (or (or (or (and x4 x3) (or x3 x6)) (and (and x4 x1) (or x4 x2))) (or (not (and x2 x6)) (or (not x0) (and x4 x5)))) (and (or (not (not x0)) (or (or x3 x7) (and x4 x2))) (or (not (and x0 x3)) (or (and x5 x0) (or x2 x3))))) (or (or (or (not (not x6)) (or (or x3 x1) (and x3 x4))) (and (or (or x0 x3) (or x3 x4)) (or (and x7 x0) (not x4)))) (or (not (not (and x7 x5))) (not (or (and x4 x3) (not x7))))))))))) +(assert (or (or x2 x1) (or x2 x4))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (or (and (not (or (or x5 x0) (or x7 x1))) (and (not (not x4)) (not (not x6)))) (not (not (or (or x4 x3) (not x2))))))) +(assert (and (and (and (and (not (not (and (or (and x7 x4) (and x7 x6)) (or (or x6 x5) (or x5 x3))))) (or (not (not (or (and x6 x6) (or x2 x6)))) (not (or (and (or x7 x5) (not x3)) (or (not x7) (not x0)))))) (or (or (and (or (not (not x1)) (and (or x0 x0) (and x4 x7))) (not (or (or x4 x5) (and x2 x5)))) (not (and (or (or x7 x0) (or x3 x1)) (not (and x3 x2))))) (and (not (and (not (or x4 x0)) (not (not x7)))) (and (not (not (and x1 x0))) (or (and (or x5 x5) (and x4 x5)) (not (not x6))))))) (not (and (or (not (or (or (and x0 x7) (not x0)) (or (and x7 x0) (and x0 x4)))) (and (not (not (not x0))) (or (and (not x3) (or x4 x2)) (not (and x1 x1))))) (and (and (or (or (and x0 x7) (or x0 x3)) (and (not x3) (or x4 x4))) (or (or (not x3) (or x7 x4)) (not (or x1 x2)))) (not (not (and (and x2 x5) (not x5)))))))) (not (not (and (or (and (or (not (not x3)) (or (or x0 x3) (and x3 x6))) (not (not (and x5 x4)))) (not (and (and (or x3 x7) (and x0 x2)) (or (and x5 x7) (not x1))))) (not (not (and (and (or x5 x3) (not x4)) (not (not x1)))))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (not (not (and (or (or (and x3 x5) (or x2 x6)) (not (not x7))) (or (not (and x2 x7)) (or (and x0 x1) (or x6 x1)))))) (not (and (not (not (or (or x0 x7) (and x1 x1)))) (not (or (not (or x4 x4)) (or (or x1 x4) (and x3 x3))))))))) +(assert (or x5 x7)) +(check-sat) +(push 1) +(assert (and (or (not (not (or x5 x3))) (and (or (or x4 x5) (or x2 x1)) (and (not x5) (and x1 x3)))) (not (and (or (not x0) (not x7)) (not (not x5)))))) +(assert (or (and (not (and (or (and (or (and x2 x3) (not x4)) (or (and x1 x1) (or x3 x5))) (or (not (and x4 x7)) (and (and x1 x2) (or x4 x0)))) (and (not (not (or x0 x3))) (or (not (not x4)) (and (and x1 x5) (not x2)))))) (and (or (not (not (or (and x1 x5) (not x5)))) (and (or (and (not x6) (or x7 x3)) (or (and x7 x0) (and x4 x4))) (not (not (not x5))))) (and (and (not (and (and x2 x4) (or x4 x1))) (or (and (and x4 x0) (not x2)) (and (or x6 x2) (and x5 x2)))) (not (not (not (not x7))))))) (or (and (or (and (and (not (or x3 x4)) (and (not x5) (not x1))) (not (or (not x7) (or x5 x0)))) (and (not (and (and x1 x7) (or x7 x5))) (not (and (not x0) (or x2 x0))))) (not (and (or (or (not x1) (or x6 x6)) (and (and x5 x4) (or x5 x6))) (not (or (not x4) (and x5 x4)))))) (not (not (or (and (and (not x5) (not x2)) (and (not x3) (or x3 x2))) (not (and (not x5) (and x6 x1))))))))) +(assert (or (not (or (not (not (or (and (and (and x5 x4) (not x4)) (or (not x6) (and x2 x1))) (or (and (or x0 x7) (not x5)) (not (and x7 x4)))))) (not (and (and (or (and (or x7 x3) (not x3)) (or (not x5) (not x3))) (not (not (not x7)))) (not (or (not (or x2 x4)) (not (and x3 x0)))))))) (and (not (not (or (and (or (and (not x7) (not x1)) (not (not x4))) (not (and (or x4 x1) (or x3 x5)))) (or (not (and (not x3) (and x3 x6))) (and (not (or x0 x5)) (not (and x5 x6))))))) (or (not (not (not (and (not (and x4 x3)) (not (not x1)))))) (not (and (or (and (or (or x2 x7) (and x0 x7)) (or (and x7 x7) (and x7 x4))) (and (and (not x6) (or x2 x2)) (and (and x5 x3) (and x6 x2)))) (or (and (not (or x5 x3)) (or (or x3 x3) (or x1 x2))) (not (not (or x3 x1)))))))))) +(assert (not (or (or (and (and (and (or (and (or x5 x5) (or x6 x6)) (and (and x1 x2) (not x5))) (and (or (not x7) (or x1 x1)) (and (and x2 x2) (and x2 x5)))) (not (not (and (not x4) (not x1))))) (and (or (not (not (not x2))) (and (and (not x7) (or x4 x5)) (and (and x6 x2) (not x1)))) (not (and (not (or x4 x0)) (or (and x3 x4) (or x4 x6)))))) (and (and (or (and (not (not x5)) (not (not x6))) (or (not (not x0)) (and (or x5 x4) (not x5)))) (and (or (not (and x2 x3)) (and (or x7 x0) (and x6 x3))) (and (not (or x3 x4)) (or (or x2 x0) (not x0))))) (and (not (and (not (or x5 x3)) (not (or x5 x7)))) (and (or (not (and x7 x3)) (not (and x6 x6))) (or (or (not x0) (and x4 x2)) (not (and x3 x4))))))) (and (or (and (not (not (not (and x1 x3)))) (or (or (or (or x3 x3) (and x7 x1)) (or (not x5) (or x7 x6))) (and (or (and x0 x7) (or x4 x5)) (or (and x3 x1) (not x1))))) (or (and (and (not (and x6 x1)) (not (or x1 x2))) (and (not (not x4)) (and (or x0 x2) (or x0 x1)))) (or (not (and (not x4) (or x2 x2))) (and (and (or x1 x2) (not x7)) (and (and x0 x5) (or x2 x4)))))) (and (and (not (and (and (not x7) (not x5)) (or (and x4 x2) (and x6 x4)))) (and (or (not (not x2)) (and (not x1) (not x3))) (and (and (or x3 x0) (and x2 x2)) (or (not x7) (or x0 x4))))) (and (not (or (and (or x6 x4) (not x7)) (or (not x1) (and x2 x2)))) (and (or (or (not x5) (and x2 x1)) (or (not x7) (not x4))) (or (not (and x2 x7)) (or (not x5) (or x6 x7)))))))))) +(assert (not x0)) +(assert (and x0 x7)) +(assert (not (not (or (and x6 x2) (and x0 x6))))) +(assert (or (not x2) (and x5 x0))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (and (or (or x0 x0) (and x3 x5)) (not (not x4)))))) +(check-sat) +(pop 1) +(assert (and (not (or (and x6 x2) (not x4))) (not (and (or x1 x7) (or x0 x6))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_40.smt2 b/test/regress/regress1/push-pop/fuzz_40.smt2 new file mode 100644 index 000000000..dfde9eef6 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_40.smt2 @@ -0,0 +1,41 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (and (not (or (and (or (or x0 x3) (or x2 x1)) (and (or x1 x0) (not x0))) (or (and (not x2) (and x2 x3)) (not (and x2 x1))))) (and (not (and (or (and x3 x1) (not x2)) (not (or x3 x3)))) (or (not (and (and x1 x2) (and x0 x0))) (or (or (or x3 x2) (not x1)) (or (and x3 x2) (not x0)))))))) +(check-sat) +(push 1) +(assert (and (and x3 x1) (and x2 x2))) +(check-sat) +(pop 1) +(assert (or (or (and (not (or (and (not (and (not (not x1)) (or (and x0 x2) (and x0 x3)))) (not (not (and (not x1) (and x0 x3))))) (not (not (not (and (not x0) (not x2))))))) (not (or (not (and (not (or (or x1 x1) (not x1))) (not (or (not x3) (or x3 x0))))) (not (or (not (or (or x2 x0) (not x3))) (and (not (and x0 x2)) (not (and x2 x3)))))))) (and (or (not (or (not (not (or (or x3 x2) (and x2 x3)))) (and (or (or (not x3) (or x0 x2)) (not (and x1 x2))) (or (and (or x3 x2) (not x0)) (and (and x3 x3) (not x2)))))) (not (not (not (or (and (or x1 x3) (or x2 x2)) (or (not x0) (not x1))))))) (and (or (not (or (and (or (and x1 x3) (or x2 x2)) (or (not x1) (not x3))) (or (or (and x2 x0) (not x3)) (not (not x1))))) (or (or (not (not (not x0))) (not (or (not x0) (not x1)))) (or (and (and (or x2 x1) (and x2 x0)) (not (and x0 x2))) (not (and (not x0) (or x3 x1)))))) (and (not (and (and (or (and x3 x0) (and x0 x1)) (not (or x1 x1))) (not (and (not x3) (not x0))))) (not (and (or (not (not x1)) (and (not x0) (or x1 x0))) (not (not (and x1 x1))))))))) (and (not (not (not (and (or (and (and (or x2 x3) (not x0)) (or (and x3 x3) (and x2 x0))) (or (not (or x2 x1)) (not (or x3 x1)))) (and (and (and (and x3 x2) (or x3 x2)) (not (not x0))) (or (and (or x2 x1) (and x1 x0)) (and (not x2) (not x1)))))))) (and (or (and (or (not (not (not (or x2 x0)))) (not (or (and (and x2 x2) (and x2 x1)) (and (and x3 x0) (or x1 x0))))) (not (or (or (and (not x2) (and x2 x1)) (not (not x0))) (not (and (and x3 x0) (or x1 x3)))))) (not (or (not (or (and (and x2 x2) (not x3)) (or (not x2) (or x0 x2)))) (or (or (and (or x0 x1) (or x0 x1)) (not (not x2))) (or (or (and x2 x0) (and x1 x2)) (and (not x1) (or x3 x3))))))) (or (and (or (and (and (or (and x3 x3) (and x0 x0)) (or (or x0 x3) (or x0 x3))) (and (not (or x3 x3)) (and (not x3) (or x1 x2)))) (and (and (and (not x0) (or x1 x3)) (or (not x2) (or x1 x2))) (and (or (not x3) (or x0 x0)) (or (not x0) (not x2))))) (and (not (and (or (not x3) (not x0)) (or (not x2) (or x0 x3)))) (not (not (not (and x0 x0)))))) (or (and (and (and (or (not x1) (not x0)) (and (or x2 x0) (not x2))) (or (not (and x1 x2)) (and (or x2 x2) (not x2)))) (and (not (not (not x3))) (or (and (not x0) (and x2 x1)) (and (not x3) (not x1))))) (or (and (or (not (or x1 x2)) (or (and x2 x1) (not x0))) (and (or (and x3 x0) (or x2 x3)) (or (or x0 x3) (and x3 x2)))) (or (not (not (and x2 x2))) (or (not (not x2)) (or (or x0 x3) (or x0 x2))))))))))) +(check-sat) +(push 1) +(assert (or (or (not x3) (and x3 x0)) (not (and x3 x1)))) +(assert (not x0)) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (or (or (and (and (not (or (not x1) (and x1 x1))) (and (and (or x3 x3) (not x2)) (and (not x0) (or x2 x1)))) (not (or (or (and x0 x2) (not x2)) (not (and x0 x1))))) (not (and (or (and (and x0 x1) (not x0)) (or (and x0 x2) (or x1 x3))) (and (or (or x3 x1) (and x3 x1)) (or (or x3 x1) (not x0)))))) (and (and (not (not (not (or x1 x2)))) (or (or (or (not x1) (and x0 x3)) (and (not x2) (not x0))) (or (or (not x1) (not x1)) (and (and x2 x1) (not x2))))) (not (not (and (not (or x2 x2)) (and (not x2) (and x1 x2)))))))) (not (or (and (and (not (not (and (and x3 x2) (and x0 x3)))) (not (not (not (not x1))))) (and (not (not (and (not x2) (not x1)))) (not (or (or (or x2 x3) (not x1)) (and (and x0 x1) (or x3 x0)))))) (and (not (and (and (and (not x3) (not x0)) (and (not x0) (or x3 x2))) (not (and (and x0 x2) (and x3 x0))))) (not (and (and (not (and x1 x1)) (or (and x1 x1) (or x0 x1))) (not (or (or x0 x0) (and x2 x3)))))))))) +(check-sat) +(pop 1) +(assert (not (and (and (and (or (or (or (and x0 x2) (and x1 x3)) (or (not x0) (and x2 x1))) (and (or (and x0 x2) (not x2)) (or (not x3) (and x1 x0)))) (or (not (or (and x1 x1) (or x1 x3))) (and (and (and x0 x0) (and x2 x2)) (and (not x0) (or x2 x3))))) (not (not (and (not (or x0 x2)) (or (and x1 x2) (or x2 x3)))))) (or (and (or (not (or (not x3) (or x1 x1))) (and (not (or x2 x2)) (or (or x3 x3) (and x3 x3)))) (not (or (or (and x2 x2) (and x1 x2)) (not (not x1))))) (not (not (not (and (or x0 x3) (or x3 x2))))))))) +(assert (or (not (and (not x1) (not x3))) (or (not (and x2 x0)) (and (or x1 x0) (or x2 x1))))) +(assert (and (not (or (and x2 x0) (not x0))) (or (not (and x1 x1)) (and (and x1 x3) (and x3 x3))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_41.smt2 b/test/regress/regress1/push-pop/fuzz_41.smt2 new file mode 100644 index 000000000..b6d2e884f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_41.smt2 @@ -0,0 +1,25 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(check-sat) +(push 1) +(assert (or (or (or (and (and (not (and (or x0 x0) (not x0))) (not (or (or x2 x2) (not x0)))) (or (or (not (or x0 x0)) (or (and x0 x2) (or x0 x2))) (and (and (and x1 x1) (and x2 x1)) (not (not x2))))) (and (not (not (and (not x2) (and x0 x2)))) (not (not (and (not x2) (not x1)))))) (not (or (and (not (and (not x2) (not x0))) (and (not (not x0)) (and (not x1) (and x2 x2)))) (and (not (and (not x2) (or x1 x0))) (or (or (or x1 x0) (or x0 x0)) (or (or x0 x0) (not x1))))))) (not (not (not (and (not (or (or x2 x0) (not x2))) (not (and (not x0) (or x0 x1))))))))) +(assert (or (not (or (and (or (or x0 x0) (or x2 x2)) (and (not x1) (or x2 x2))) (and (not (not x1)) (and (or x0 x0) (or x0 x1))))) (not (and (or (and (and x1 x2) (not x1)) (not (not x2))) (not (and (and x2 x0) (not x1))))))) +(assert (or (not (not x2)) (not (not x0)))) +(assert (not (or (not (or (and (and (and x0 x0) (or x1 x1)) (or (or x0 x2) (not x1))) (not (or (or x0 x1) (or x0 x0))))) (not (not (not (or (or x1 x1) (not x2)))))))) +(check-sat) +(pop 1) +(assert (not (and (not (and (and (or (and (and (or (not x0) (not x1)) (and (or x1 x1) (not x2))) (and (and (or x1 x0) (and x1 x2)) (and (not x0) (not x2)))) (not (or (or (or x1 x0) (not x1)) (or (or x0 x1) (not x2))))) (or (or (and (not (not x0)) (or (or x0 x1) (not x0))) (or (not (or x0 x2)) (not (or x0 x0)))) (not (and (or (and x1 x1) (not x0)) (or (and x1 x1) (or x1 x0)))))) (or (and (not (or (not (and x0 x0)) (and (and x0 x2) (and x2 x0)))) (not (and (and (or x0 x2) (and x0 x2)) (and (not x0) (and x0 x1))))) (and (or (not (and (and x2 x1) (not x2))) (or (and (and x2 x2) (and x2 x2)) (or (or x0 x1) (or x1 x2)))) (or (and (and (and x2 x1) (or x1 x0)) (and (or x2 x0) (not x1))) (and (not (or x2 x2)) (or (and x2 x0) (and x0 x0)))))))) (or (and (or (not (and (not (not (or x2 x0))) (and (or (and x0 x1) (or x0 x1)) (not (not x1))))) (not (and (and (or (or x0 x1) (not x1)) (not (not x2))) (not (or (not x2) (not x2)))))) (and (or (and (or (not (and x2 x2)) (or (and x1 x2) (or x2 x2))) (and (or (not x2) (and x2 x2)) (not (not x2)))) (not (not (and (not x2) (not x1))))) (not (and (and (and (or x1 x1) (and x0 x0)) (or (or x0 x0) (not x1))) (or (and (or x2 x1) (not x2)) (and (or x2 x2) (not x1))))))) (not (or (and (and (or (or (not x2) (not x0)) (not (and x1 x0))) (and (not (not x0)) (or (and x1 x0) (or x1 x0)))) (and (and (or (and x0 x2) (not x2)) (and (or x2 x2) (not x1))) (not (or (and x0 x1) (and x1 x0))))) (or (not (or (not (and x1 x0)) (not (not x2)))) (not (not (and (or x2 x0) (not x1))))))))))) +(check-sat) +(push 1) +(assert (or (and (and (or (or (and (not (and (or (or x2 x0) (or x0 x1)) (not (or x2 x1)))) (or (not (not (not x2))) (not (not (or x1 x1))))) (or (or (and (or (and x2 x0) (not x1)) (or (or x2 x2) (and x1 x2))) (or (or (and x0 x0) (and x2 x0)) (or (not x2) (or x0 x1)))) (and (or (and (or x0 x0) (or x2 x0)) (not (not x1))) (not (and (or x1 x2) (or x1 x1)))))) (and (not (not (and (or (or x1 x0) (and x1 x1)) (not (or x1 x0))))) (and (and (and (or (or x0 x2) (and x0 x2)) (and (and x2 x2) (and x0 x1))) (or (or (or x1 x1) (not x2)) (not (not x1)))) (not (not (or (or x1 x0) (and x2 x0))))))) (not (not (and (or (not (or (and x1 x2) (not x2))) (and (and (or x2 x0) (and x1 x0)) (and (or x1 x0) (or x2 x1)))) (not (or (not (not x0)) (not (and x2 x2)))))))) (and (or (and (or (not (not (and (and x1 x1) (and x1 x1)))) (or (and (not (and x0 x1)) (or (or x2 x2) (or x0 x1))) (and (not (not x0)) (not (and x0 x0))))) (not (and (or (and (not x1) (not x2)) (not (or x2 x1))) (and (and (not x0) (and x0 x2)) (or (and x2 x2) (not x2)))))) (or (and (and (not (and (or x1 x0) (or x0 x1))) (not (or (or x2 x1) (or x1 x0)))) (and (and (or (and x1 x1) (not x2)) (or (not x0) (and x0 x1))) (not (not (or x0 x2))))) (not (and (not (or (and x2 x0) (or x2 x0))) (not (not (not x0))))))) (or (or (not (and (and (not (not x0)) (or (and x1 x2) (not x0))) (and (not (not x0)) (and (or x0 x2) (not x1))))) (and (not (and (or (not x1) (and x0 x0)) (and (not x1) (and x2 x2)))) (not (and (or (and x0 x0) (not x0)) (and (not x2) (and x0 x2)))))) (and (and (or (not (or (not x1) (or x1 x2))) (or (or (and x1 x1) (and x0 x0)) (not (and x0 x0)))) (not (or (and (or x0 x0) (not x1)) (or (and x0 x2) (or x1 x1))))) (not (and (not (not (and x2 x1))) (or (and (not x1) (not x0)) (not (or x0 x2))))))))) (or (and (or (and (not (or (or (or (not x1) (or x0 x0)) (and (or x2 x1) (not x1))) (and (or (not x2) (or x1 x2)) (or (and x2 x1) (and x1 x0))))) (and (not (and (and (or x2 x0) (not x2)) (and (or x1 x1) (or x2 x0)))) (not (or (and (and x0 x2) (and x0 x2)) (not (or x1 x1)))))) (not (or (not (or (and (and x0 x1) (not x1)) (or (and x2 x1) (not x2)))) (and (and (and (not x2) (and x2 x1)) (not (or x2 x2))) (and (and (or x1 x1) (not x1)) (or (and x0 x1) (not x1))))))) (not (and (or (and (or (or (not x2) (not x1)) (not (and x1 x1))) (or (not (or x0 x0)) (not (and x2 x1)))) (not (and (not (and x1 x1)) (or (not x1) (and x0 x2))))) (or (or (or (not (or x2 x2)) (and (and x1 x0) (and x1 x1))) (not (and (or x1 x0) (or x0 x2)))) (and (not (or (or x2 x2) (and x2 x0))) (not (and (and x2 x2) (or x1 x1)))))))) (not (or (not (or (not (and (not (and x2 x2)) (and (or x0 x1) (and x2 x0)))) (and (not (not (and x2 x0))) (or (and (and x0 x0) (not x0)) (and (and x0 x1) (not x0)))))) (or (not (or (or (and (and x0 x2) (and x2 x0)) (and (and x2 x1) (or x2 x2))) (and (or (or x0 x0) (or x1 x0)) (and (and x2 x1) (or x0 x1))))) (and (or (or (not (or x0 x1)) (not (or x0 x1))) (or (not (not x0)) (not (and x0 x2)))) (not (not (or (or x2 x2) (not x2))))))))))) +(check-sat) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_42.smt2 b/test/regress/regress1/push-pop/fuzz_42.smt2 new file mode 100644 index 000000000..2e737763f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_42.smt2 @@ -0,0 +1,48 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (or (and (and (or (or (not (not (not (and x3 x2)))) (and (and (or (and x1 x1) (not x9)) (or (or x9 x5) (not x5))) (or (not (or x6 x3)) (not (not x5))))) (or (not (or (and (and x2 x5) (or x5 x6)) (not (or x0 x5)))) (not (or (or (or x0 x6) (not x1)) (not (not x9)))))) (or (and (not (or (or (not x2) (and x9 x9)) (or (not x6) (and x8 x5)))) (and (or (not (not x8)) (not (not x5))) (and (or (or x7 x1) (and x6 x9)) (or (and x5 x5) (and x0 x8))))) (and (and (or (or (not x9) (and x3 x0)) (and (or x6 x4) (and x0 x2))) (not (not (not x3)))) (or (or (or (or x2 x4) (or x8 x5)) (not (not x5))) (and (not (or x9 x9)) (not (not x1))))))) (and (or (and (and (not (not (or x9 x7))) (not (or (or x1 x5) (and x5 x0)))) (and (and (or (and x4 x3) (or x4 x4)) (and (or x7 x7) (or x6 x3))) (not (or (not x5) (or x8 x5))))) (or (or (not (and (or x1 x1) (and x4 x7))) (or (or (or x0 x3) (or x6 x8)) (and (not x5) (not x9)))) (and (and (and (and x8 x4) (and x5 x7)) (and (not x5) (not x5))) (not (not (not x8)))))) (not (or (and (or (or (not x6) (and x6 x9)) (and (and x0 x3) (or x4 x3))) (not (and (not x8) (and x3 x2)))) (or (and (not (or x6 x9)) (and (or x2 x4) (or x6 x4))) (not (and (or x1 x4) (and x1 x9)))))))) (or (not (and (not (and (or (not (not x0)) (not (or x5 x5))) (or (or (not x9) (or x8 x5)) (and (or x2 x1) (or x4 x4))))) (not (and (or (and (and x5 x6) (or x2 x3)) (or (not x3) (and x1 x0))) (and (and (and x3 x9) (and x1 x7)) (or (not x9) (and x7 x5))))))) (or (not (or (or (not (not (and x5 x0))) (or (and (not x3) (not x8)) (or (and x5 x7) (not x8)))) (or (and (and (or x3 x9) (or x5 x6)) (or (or x0 x7) (and x7 x6))) (or (or (or x3 x3) (not x7)) (not (or x4 x4)))))) (not (not (and (not (or (or x8 x5) (not x9))) (not (or (and x3 x3) (or x3 x2)))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (or (or x0 x9) (not x9)) (not (or x8 x3)))) +(check-sat) +(push 1) +(assert (or (not (not (and x5 x8))) (not (not (not x7))))) +(check-sat) +(pop 1) +(assert (not (not (or (or (not x4) (not x5)) (not (not x6)))))) +(assert (not (not (and (and x8 x5) (or x4 x1))))) +(assert (and (not (not (or (or (and (and (or (and x7 x6) (or x2 x3)) (or (or x3 x4) (not x6))) (or (not (or x9 x1)) (not (and x7 x8)))) (and (not (not (and x2 x0))) (not (and (not x7) (or x3 x3))))) (and (or (and (not (and x2 x0)) (and (or x5 x9) (and x4 x2))) (or (or (not x2) (and x4 x4)) (or (and x4 x7) (not x0)))) (and (or (not (not x8)) (or (or x2 x0) (or x2 x6))) (and (and (not x3) (or x9 x9)) (or (not x2) (and x4 x6)))))))) (not (or (not (not (and (not (or (and x7 x9) (or x0 x0))) (not (not (or x7 x9)))))) (and (not (or (and (not (or x0 x6)) (and (and x7 x3) (and x7 x8))) (or (and (not x7) (or x5 x6)) (and (not x9) (or x4 x2))))) (and (not (or (or (and x2 x2) (not x3)) (or (and x2 x0) (or x5 x4)))) (not (or (or (not x7) (or x0 x5)) (or (or x4 x8) (and x8 x2)))))))))) +(assert (or (not (and x0 x3)) (or (or x0 x1) (or x2 x7)))) +(check-sat) +(pop 1) +(assert (or x4 x9)) +(check-sat) +(push 1) +(assert (or (or (or (not (or x9 x3)) (and (and x1 x9) (not x3))) (not (or (or x6 x1) (or x9 x8)))) (and (and (not (and x0 x6)) (and (not x0) (not x2))) (and (and (or x4 x5) (or x2 x8)) (and (and x5 x1) (and x4 x9)))))) +(check-sat) +(pop 1) +(assert (and (not (or (and (not (not (not (or x9 x5)))) (not (or (not (or x5 x4)) (not (or x8 x9))))) (and (or (not (and (or x0 x0) (not x8))) (not (or (and x7 x5) (or x0 x2)))) (or (not (not (not x2))) (and (and (or x0 x4) (and x2 x2)) (and (and x6 x7) (not x9))))))) (and (and (not (not (or (or (not x8) (and x9 x1)) (and (and x5 x8) (or x9 x3))))) (and (and (not (or (not x7) (and x0 x9))) (and (not (and x3 x4)) (not (or x4 x0)))) (or (or (and (and x0 x0) (or x1 x5)) (and (and x7 x5) (and x6 x0))) (and (and (or x4 x7) (not x6)) (not (and x1 x0)))))) (or (or (and (and (or (and x5 x1) (not x5)) (not (and x2 x4))) (and (and (not x6) (or x1 x6)) (not (and x1 x1)))) (and (and (and (or x1 x6) (or x7 x2)) (not (not x8))) (not (and (and x6 x1) (not x1))))) (not (or (or (and (or x0 x9) (not x6)) (not (not x8))) (and (and (or x7 x2) (or x7 x0)) (not (not x5))))))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_43.smt2 b/test/regress/regress1/push-pop/fuzz_43.smt2 new file mode 100644 index 000000000..88349dbff --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_43.smt2 @@ -0,0 +1,53 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(check-sat) +(push 1) +(assert (not (not (or (and (or (or x1 x1) (and x0 x1)) (or (or x2 x0) (or x0 x0))) (not (and (or x2 x0) (not x1))))))) +(assert (and (and x0 x1) (and x1 x0))) +(assert (or (not (or (or (or (and (or (and (and x1 x2) (and x1 x1)) (and (not x1) (and x2 x0))) (or (not (not x2)) (or (and x1 x1) (and x2 x1)))) (or (or (not (or x1 x2)) (and (or x0 x2) (or x2 x1))) (not (or (and x1 x2) (or x2 x0))))) (or (not (or (and (or x2 x0) (or x2 x1)) (and (not x2) (and x2 x1)))) (or (not (and (or x2 x1) (and x2 x2))) (and (and (not x1) (and x0 x2)) (and (and x0 x2) (or x1 x2)))))) (not (and (or (or (or (not x2) (and x0 x1)) (or (or x2 x2) (or x2 x2))) (and (and (not x2) (not x0)) (not (and x1 x0)))) (or (not (not (or x2 x0))) (and (not (or x2 x2)) (not (not x2)))))))) (not (or (and (not (and (and (not (not x2)) (and (not x2) (not x2))) (or (and (not x0) (or x1 x1)) (or (and x1 x0) (and x0 x0))))) (and (or (or (not (and x1 x1)) (not (or x1 x1))) (not (and (and x1 x0) (or x2 x0)))) (not (not (or (not x2) (and x0 x0)))))) (or (or (and (and (not (and x1 x1)) (or (or x0 x0) (or x2 x2))) (not (and (and x1 x0) (not x0)))) (or (not (not (and x1 x2))) (or (or (not x1) (and x1 x2)) (or (or x0 x2) (and x0 x0))))) (and (or (not (and (or x2 x2) (and x2 x2))) (and (not (not x1)) (and (or x1 x2) (and x1 x0)))) (not (or (not (or x1 x0)) (not (or x0 x2)))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (and (not (and x1 x1)) (and (and x0 x0) (not x2))))) +(check-sat) +(push 1) +(assert (or (and (or (and (or (and x0 x0) (not x0)) (and (and x1 x0) (or x0 x1))) (or (or (or x1 x1) (and x2 x2)) (not (and x0 x0)))) (or (and (and (and x2 x0) (not x1)) (or (or x2 x2) (and x0 x0))) (and (or (and x1 x1) (and x2 x1)) (and (not x0) (and x1 x0))))) (not (not (or (or (or x1 x1) (or x1 x0)) (not (or x2 x1))))))) +(assert (not (not (and (and (or (or (and x0 x2) (or x2 x0)) (and (and x1 x1) (or x1 x2))) (and (or (and x1 x0) (not x1)) (or (and x0 x0) (not x2)))) (not (and (not (or x2 x0)) (not (not x0)))))))) +(assert (not (or (and (and x1 x0) (not x2)) (or (or x2 x1) (or x0 x2))))) +(assert (or (not (and (or (and (or (not (or (and x1 x0) (not x2))) (and (not (or x2 x1)) (not (or x0 x2)))) (and (not (and (not x2) (or x0 x2))) (not (or (not x0) (and x0 x2))))) (or (not (and (and (or x1 x2) (not x1)) (or (not x0) (or x0 x1)))) (or (and (and (not x1) (and x2 x1)) (and (and x2 x1) (or x1 x0))) (or (not (or x1 x1)) (or (or x1 x2) (not x1)))))) (not (or (not (not (not (or x1 x0)))) (not (or (and (or x0 x0) (not x2)) (not (or x1 x2)))))))) (or (and (or (not (or (or (or (and x1 x0) (or x0 x0)) (or (or x2 x1) (not x2))) (not (not (and x2 x2))))) (not (not (or (and (or x2 x1) (or x1 x2)) (or (and x2 x1) (or x0 x1)))))) (not (and (not (not (not (and x2 x1)))) (and (and (not (not x1)) (and (not x0) (not x1))) (or (or (or x2 x1) (not x2)) (and (not x1) (not x0))))))) (or (and (or (not (not (not (and x1 x2)))) (or (not (and (or x0 x0) (not x0))) (and (not (not x1)) (not (and x0 x2))))) (and (and (and (and (and x2 x1) (or x2 x2)) (not (or x0 x1))) (not (not (and x1 x2)))) (and (and (not (or x0 x1)) (or (and x2 x2) (not x1))) (and (and (or x2 x2) (not x1)) (and (or x1 x1) (or x2 x0)))))) (or (and (not (and (and (and x0 x1) (not x1)) (or (or x0 x0) (not x0)))) (and (or (not (and x1 x2)) (not (or x0 x2))) (and (or (or x0 x1) (or x2 x0)) (not (or x1 x0))))) (not (and (not (and (and x0 x1) (and x0 x0))) (not (or (not x0) (or x1 x0)))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (and (or (and x0 x2) (not x2)) (and (and x1 x0) (not x0))) (not (and (and x2 x1) (or x0 x1)))))) +(check-sat) +(push 1) +(assert (and (not (and (or (not (and (and (not (not (or x2 x1))) (or (not (or x2 x2)) (and (not x2) (and x0 x1)))) (or (and (not (or x1 x2)) (and (and x2 x1) (or x2 x0))) (not (and (or x1 x2) (not x0)))))) (not (or (or (not (not (not x2))) (not (or (or x1 x1) (and x0 x1)))) (or (and (not (not x0)) (and (or x0 x0) (not x1))) (or (not (and x1 x2)) (and (and x0 x0) (and x1 x0))))))) (and (and (or (or (and (or (and x2 x0) (not x0)) (or (or x2 x1) (and x2 x1))) (or (or (or x2 x1) (not x0)) (or (and x2 x2) (not x2)))) (or (and (or (or x2 x0) (and x0 x1)) (not (and x1 x0))) (or (or (not x0) (not x0)) (or (not x2) (not x0))))) (not (or (and (and (not x1) (and x0 x0)) (not (and x1 x0))) (or (and (and x0 x2) (and x1 x0)) (and (and x0 x0) (not x1)))))) (or (and (or (or (and (and x2 x0) (or x0 x2)) (or (and x2 x2) (not x2))) (or (and (or x0 x1) (and x2 x2)) (or (and x0 x0) (or x2 x1)))) (not (or (and (and x2 x1) (not x2)) (and (not x1) (and x1 x0))))) (or (or (and (not (and x0 x1)) (and (or x0 x1) (not x1))) (not (or (and x2 x0) (and x1 x1)))) (or (or (and (and x2 x0) (or x0 x1)) (and (not x2) (or x2 x1))) (and (or (not x1) (not x1)) (or (and x2 x1) (not x1))))))))) (and (or (not (or (not (or (and (and (or x2 x1) (or x0 x2)) (or (or x0 x2) (and x1 x0))) (not (or (or x0 x1) (and x2 x2))))) (or (or (and (and (and x2 x0) (and x1 x1)) (and (or x0 x0) (and x1 x1))) (and (and (and x1 x1) (not x0)) (and (not x1) (not x0)))) (and (or (and (not x2) (not x1)) (not (or x0 x0))) (not (not (and x1 x0))))))) (or (not (not (not (and (and (and x2 x0) (not x1)) (or (or x1 x0) (and x2 x2)))))) (not (and (and (or (or (not x0) (not x0)) (and (and x1 x1) (and x0 x1))) (and (and (not x2) (and x2 x1)) (not (not x2)))) (and (or (and (or x2 x0) (or x2 x1)) (and (and x2 x1) (and x0 x2))) (not (not (not x0)))))))) (and (or (not (and (and (and (and (or x1 x1) (not x0)) (not (not x1))) (or (not (not x2)) (and (and x1 x1) (not x0)))) (and (or (or (and x2 x2) (or x0 x1)) (and (and x0 x2) (not x1))) (and (not (not x2)) (and (not x2) (not x1)))))) (not (or (or (or (and (and x1 x1) (not x0)) (not (and x2 x0))) (and (and (and x1 x1) (not x0)) (or (and x2 x0) (or x2 x0)))) (not (and (not (not x2)) (or (or x1 x2) (not x0))))))) (and (not (not (or (and (and (and x2 x2) (not x1)) (not (or x2 x1))) (or (not (and x0 x0)) (not (and x2 x1)))))) (or (not (not (not (not (not x0))))) (or (not (and (or (and x2 x0) (and x2 x0)) (or (not x1) (or x1 x2)))) (or (not (not (or x2 x1))) (not (not (not x0))))))))))) +(check-sat) +(push 1) +(assert (or (and (and (and (not (or (or (or (not x1) (and x2 x0)) (or (not x1) (or x0 x1))) (not (or (not x1) (or x1 x0))))) (and (or (or (and (not x2) (not x1)) (or (or x2 x2) (or x1 x0))) (not (and (and x0 x1) (or x0 x2)))) (not (or (or (and x1 x0) (or x0 x2)) (and (and x1 x1) (or x0 x0)))))) (not (and (not (not (or (or x0 x2) (not x2)))) (or (not (not (and x2 x2))) (not (not (and x1 x1))))))) (not (not (or (and (not (not (not x0))) (and (or (not x2) (not x2)) (not (and x0 x0)))) (or (or (and (not x2) (not x2)) (or (not x2) (and x2 x1))) (and (and (not x0) (or x2 x2)) (and (or x1 x1) (not x0)))))))) (not (or (and (or (or (or (and (and x0 x1) (or x0 x1)) (and (or x0 x0) (not x2))) (not (and (not x0) (or x2 x2)))) (and (or (and (not x1) (or x2 x0)) (not (not x0))) (or (or (and x1 x1) (not x0)) (not (or x0 x0))))) (not (not (or (or (not x1) (not x2)) (and (or x2 x2) (not x1)))))) (and (and (not (or (and (or x0 x2) (not x2)) (not (and x2 x2)))) (and (and (or (or x1 x1) (not x1)) (not (and x0 x0))) (not (not (not x2))))) (and (and (and (and (and x1 x1) (not x0)) (not (not x2))) (and (not (not x0)) (or (or x1 x0) (and x1 x1)))) (or (or (and (and x0 x1) (or x0 x0)) (or (not x1) (and x0 x1))) (not (and (and x1 x1) (not x1)))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and x2 x2)) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_44.smt2 b/test/regress/regress1/push-pop/fuzz_44.smt2 new file mode 100644 index 000000000..968d30c2e --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_44.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(assert (or (not (not (and (and (not (not (not (not (or x2 x4))))) (and (not (or (not (not x4)) (or (or x2 x8) (or x3 x7)))) (and (or (or (not x8) (not x8)) (not (not x5))) (or (not (not x3)) (or (or x3 x7) (or x5 x2)))))) (or (and (and (or (and (and x8 x5) (not x5)) (and (or x8 x6) (not x7))) (and (and (or x7 x2) (or x6 x5)) (and (or x8 x6) (and x4 x0)))) (not (or (and (not x3) (and x6 x6)) (or (not x8) (or x1 x3))))) (and (not (and (or (and x5 x0) (not x0)) (or (or x8 x3) (or x0 x5)))) (and (or (or (and x6 x0) (not x1)) (or (or x3 x3) (or x2 x7))) (not (and (not x3) (or x0 x1))))))))) (not (and (and (or (or (not (and (not (or x2 x2)) (and (and x6 x2) (or x7 x6)))) (or (and (and (not x3) (not x7)) (or (not x8) (or x0 x0))) (and (not (or x7 x3)) (or (or x8 x6) (and x2 x1))))) (not (not (or (and (and x1 x1) (or x2 x3)) (not (not x0)))))) (not (not (not (or (or (or x8 x6) (and x7 x0)) (and (not x0) (not x7))))))) (or (and (and (or (not (not (not x7))) (and (or (and x2 x8) (or x2 x8)) (or (not x8) (or x6 x8)))) (or (and (and (and x6 x4) (not x0)) (or (or x2 x4) (or x8 x1))) (or (or (not x4) (not x8)) (or (or x8 x2) (and x8 x8))))) (and (not (not (or (and x0 x2) (not x5)))) (not (or (or (not x8) (and x8 x6)) (or (or x1 x6) (and x4 x6)))))) (not (and (or (not (or (not x8) (or x8 x4))) (or (and (or x6 x7) (or x5 x2)) (or (and x8 x2) (and x5 x0)))) (not (and (or (and x2 x1) (and x1 x5)) (or (not x7) (or x5 x4))))))))))) +(assert (or (and (or (and (and (not (and x5 x1)) (and (and x6 x6) (and x6 x4))) (not (not (and x4 x1)))) (and (or (not (or x5 x0)) (or (and x4 x0) (not x2))) (and (and (or x4 x3) (or x5 x4)) (and (or x0 x3) (and x2 x5))))) (and (and (and (not (or x7 x7)) (or (and x5 x4) (or x0 x2))) (not (not (or x7 x6)))) (and (not (or (and x4 x2) (and x4 x3))) (or (and (and x1 x5) (not x3)) (or (and x2 x0) (or x7 x2)))))) (or (or (and (or (not (and x2 x6)) (or (not x3) (and x6 x4))) (or (not (and x7 x0)) (not (or x3 x2)))) (and (or (and (and x4 x1) (or x6 x8)) (or (not x0) (or x0 x0))) (and (or (not x8) (not x7)) (or (or x7 x0) (not x7))))) (or (or (not (not (not x3))) (and (or (not x6) (and x0 x5)) (or (not x6) (and x6 x6)))) (not (and (and (not x6) (not x4)) (and (or x4 x4) (not x7)))))))) +(check-sat) +(push 1) +(assert (and (or (or x8 x0) (and x1 x0)) (and (and x6 x5) (not x3)))) +(assert (and x6 x2)) +(check-sat) +(pop 1) +(assert (and (and (or x0 x6) (not x3)) (or (and x7 x7) (and x7 x3)))) +(assert (not (not (not (or x5 x3))))) +(assert (not (and (and (and (not (and x2 x3)) (or (and x1 x5) (or x4 x2))) (or (or (or x4 x7) (and x5 x1)) (and (not x1) (and x1 x4)))) (or (or (and (not x6) (not x1)) (and (not x4) (or x6 x5))) (not (not (and x4 x8))))))) +(assert (and (or (not (and (not (or (or (or (not x2) (not x0)) (or (or x6 x0) (or x7 x6))) (or (or (or x2 x3) (not x5)) (and (and x4 x6) (and x3 x0))))) (and (and (or (not (not x3)) (or (not x6) (and x6 x1))) (not (and (not x4) (and x3 x5)))) (and (not (not (and x1 x8))) (or (or (not x5) (and x4 x7)) (and (and x5 x4) (or x8 x7))))))) (or (and (not (or (or (or (not x2) (not x2)) (not (or x5 x2))) (not (and (and x6 x5) (and x0 x1))))) (or (not (or (and (and x7 x8) (and x5 x3)) (not (and x6 x4)))) (not (not (and (not x6) (or x5 x0)))))) (or (not (not (not (or (not x7) (and x7 x5))))) (or (and (or (not (or x0 x3)) (not (and x0 x2))) (not (and (not x8) (not x7)))) (or (or (and (and x7 x5) (and x7 x5)) (or (or x4 x5) (not x4))) (and (or (or x4 x4) (and x8 x5)) (not (and x8 x3)))))))) (and (or (and (not (or (not (or (and x1 x6) (or x8 x3))) (not (not (not x8))))) (and (and (or (or (not x8) (and x2 x5)) (and (and x6 x4) (not x8))) (and (and (and x0 x7) (not x2)) (not (or x3 x6)))) (and (not (not (or x7 x8))) (not (not (or x0 x5)))))) (and (not (and (or (and (not x5) (and x4 x4)) (or (or x4 x1) (or x7 x7))) (and (and (and x3 x7) (not x7)) (or (not x2) (not x2))))) (not (not (or (not (or x7 x1)) (and (and x2 x8) (not x5))))))) (or (not (and (and (or (or (or x5 x5) (and x1 x5)) (not (and x4 x1))) (and (and (and x3 x0) (and x2 x5)) (not (or x6 x5)))) (or (or (and (or x8 x4) (not x3)) (and (not x6) (and x3 x7))) (and (and (not x0) (or x5 x5)) (or (not x5) (and x8 x1)))))) (and (or (not (and (and (not x6) (not x3)) (and (not x6) (or x5 x2)))) (not (or (or (or x8 x1) (and x8 x6)) (or (not x3) (or x8 x3))))) (not (or (and (and (and x2 x2) (not x5)) (not (and x8 x0))) (and (and (not x3) (not x1)) (and (and x2 x3) (not x6)))))))))) +(assert (or (or (and (and (not x7) (or x2 x6)) (or (and x3 x2) (and x8 x1))) (not (or (and x6 x5) (or x7 x1)))) (or (and (not (not x4)) (and (and x2 x5) (or x4 x1))) (not (not (or x7 x5)))))) +(assert (or (or (and (and (and (not (or (and x4 x7) (or x6 x2))) (and (or (and x2 x8) (or x2 x4)) (and (or x4 x2) (or x7 x7)))) (or (not (or (or x3 x2) (not x1))) (and (or (or x4 x8) (or x8 x1)) (and (not x6) (and x5 x1))))) (and (and (or (not (not x3)) (and (not x1) (and x1 x5))) (not (and (and x5 x4) (or x6 x7)))) (not (or (or (not x4) (and x2 x8)) (and (not x1) (or x3 x2)))))) (not (or (not (or (or (and x2 x4) (or x5 x6)) (not (not x8)))) (not (or (not (or x1 x5)) (not (or x4 x5))))))) (or (not (and (not (not (or (not x0) (and x7 x1)))) (and (or (and (or x0 x0) (or x5 x0)) (and (not x5) (or x5 x6))) (not (or (and x1 x5) (not x7)))))) (not (and (and (not (or (and x4 x8) (or x3 x8))) (not (or (or x6 x4) (not x5)))) (not (or (and (not x0) (not x2)) (or (or x4 x6) (or x0 x2))))))))) +(assert (not (and (and (or x3 x2) (or x1 x8)) (and (and x5 x5) (not x8))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_45.smt2 b/test/regress/regress1/push-pop/fuzz_45.smt2 new file mode 100644 index 000000000..1294df46f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_45.smt2 @@ -0,0 +1,51 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (or (not (and (or (or (not (and (or x6 x3) (not x4))) (and (or (and x2 x3) (not x3)) (and (or x4 x1) (or x4 x3)))) (or (and (not (and x2 x5)) (and (and x2 x0) (and x5 x0))) (and (or (or x1 x4) (and x0 x0)) (or (and x1 x2) (not x5))))) (or (or (or (and (and x6 x5) (not x6)) (and (and x2 x3) (not x4))) (and (not (or x5 x0)) (or (and x1 x3) (and x1 x5)))) (and (not (or (and x0 x5) (and x2 x0))) (or (or (or x6 x2) (not x1)) (or (and x3 x6) (and x4 x2))))))) (and (not (or (or (not (not (or x4 x0))) (or (not (or x2 x4)) (and (not x2) (or x1 x3)))) (or (or (not (not x3)) (and (and x0 x4) (or x0 x0))) (not (and (not x0) (or x3 x2)))))) (or (or (or (or (and (not x3) (or x5 x6)) (and (or x6 x4) (or x5 x5))) (not (or (or x1 x2) (and x6 x4)))) (not (or (and (and x2 x4) (and x5 x2)) (and (not x5) (and x2 x1))))) (not (or (or (not (not x4)) (not (not x1))) (or (not (not x2)) (or (or x4 x6) (and x6 x1)))))))) (not (not (or (or (or (not (and (or x3 x2) (or x1 x4))) (and (or (and x3 x2) (and x4 x0)) (or (not x2) (and x2 x6)))) (and (not (and (and x3 x4) (not x1))) (or (not (and x3 x5)) (and (not x4) (or x5 x5))))) (not (or (or (or (or x6 x5) (or x1 x4)) (or (or x1 x4) (and x6 x0))) (not (not (not x6)))))))))) +(assert (or (and (or (and (or (and (not (and (and x5 x5) (not x6))) (not (not (not x3)))) (and (and (and (and x5 x0) (and x4 x3)) (not (and x2 x1))) (not (or (and x1 x3) (and x0 x6))))) (not (and (not (and (or x4 x1) (not x0))) (and (not (or x3 x3)) (or (or x4 x4) (not x3)))))) (or (or (not (or (and (or x3 x2) (or x3 x1)) (not (and x6 x4)))) (not (and (not (or x1 x6)) (or (not x2) (or x1 x6))))) (and (not (or (and (not x3) (and x1 x4)) (and (or x4 x1) (and x6 x6)))) (not (or (and (or x2 x2) (or x3 x1)) (or (not x2) (and x3 x1))))))) (and (not (and (not (not (or (and x6 x1) (and x1 x6)))) (or (or (and (or x5 x6) (not x5)) (or (and x5 x2) (not x5))) (and (or (and x1 x0) (or x6 x3)) (or (and x0 x5) (and x1 x3)))))) (or (and (not (or (not (or x3 x5)) (or (and x4 x2) (not x5)))) (and (not (or (not x6) (and x5 x4))) (and (or (not x3) (or x6 x3)) (not (and x1 x2))))) (and (not (and (not (or x5 x0)) (not (and x1 x3)))) (not (or (and (not x3) (or x0 x6)) (not (or x5 x3)))))))) (and (not (not (and (not (and (or (and x2 x3) (or x5 x6)) (and (not x0) (or x4 x1)))) (or (not (and (and x0 x4) (or x6 x4))) (and (not (or x3 x5)) (or (and x2 x1) (and x6 x3))))))) (not (not (not (or (and (not (or x1 x0)) (or (and x4 x1) (not x4))) (and (not (not x2)) (and (not x2) (and x3 x3)))))))))) +(check-sat) +(push 1) +(assert (or (not (not (not x6))) (and (or (and x1 x1) (not x2)) (and (or x4 x3) (not x1))))) +(assert (not (and (and x0 x3) (or x3 x4)))) +(assert (or (and x5 x3) (not x4))) +(assert (or (or (or (not (not (or (or (and x3 x2) (and x1 x2)) (and (or x5 x5) (not x6))))) (not (and (and (and (not x6) (or x1 x0)) (or (or x3 x3) (or x3 x3))) (and (or (and x0 x4) (not x3)) (or (not x1) (and x0 x6)))))) (and (and (or (or (not (and x6 x5)) (and (not x5) (or x6 x2))) (not (and (and x6 x2) (not x3)))) (not (or (or (not x5) (not x4)) (or (and x3 x6) (or x6 x1))))) (or (or (not (and (not x6) (or x1 x6))) (and (or (not x3) (and x1 x0)) (not (not x6)))) (not (not (not (not x2))))))) (not (and (and (or (not (not (not x2))) (or (and (not x3) (and x3 x4)) (not (and x1 x3)))) (or (or (and (not x0) (or x0 x0)) (or (not x3) (and x1 x0))) (not (not (and x5 x6))))) (and (and (and (not (not x2)) (not (or x6 x3))) (or (and (not x1) (not x1)) (and (and x1 x5) (and x2 x6)))) (not (not (and (not x1) (or x4 x5))))))))) +(assert (or (and (not (not (not (or (and (or (or x3 x5) (not x3)) (not (or x0 x5))) (or (or (not x3) (or x0 x2)) (or (not x3) (not x4))))))) (not (or (not (and (or (and (or x5 x1) (and x5 x2)) (not (not x5))) (not (or (not x1) (and x6 x6))))) (and (or (and (or (or x3 x1) (or x5 x4)) (and (not x2) (and x1 x2))) (and (or (and x0 x2) (and x6 x6)) (and (and x3 x4) (not x2)))) (or (and (not (not x2)) (and (not x3) (and x1 x5))) (and (not (or x1 x1)) (or (and x2 x5) (not x2)))))))) (and (or (not (not (not (and (and (not x4) (not x0)) (and (and x0 x3) (and x1 x0)))))) (and (or (not (and (and (or x2 x3) (not x2)) (or (not x2) (and x5 x4)))) (not (not (not (and x1 x4))))) (or (and (or (not (or x0 x4)) (and (not x4) (not x2))) (not (and (and x5 x0) (or x5 x1)))) (not (and (and (or x2 x4) (not x0)) (not (not x2))))))) (and (or (not (or (or (or (not x6) (not x1)) (not (or x6 x4))) (and (and (not x6) (not x4)) (not (and x3 x6))))) (not (not (not (not (not x1)))))) (not (or (or (and (not (and x4 x0)) (and (not x6) (or x4 x5))) (not (and (not x6) (or x5 x1)))) (or (and (or (or x1 x2) (or x5 x5)) (not (not x1))) (or (and (and x6 x6) (not x4)) (or (or x2 x0) (and x3 x0)))))))))) +(check-sat) +(pop 1) +(assert (or (and (not (and x2 x5)) (and (or x3 x4) (or x0 x3))) (or (or (not x1) (and x3 x3)) (not (or x5 x1))))) +(check-sat) +(push 1) +(assert (not (not (not (or (or x2 x3) (and x2 x1)))))) +(assert (not (and (not (and (or (or x4 x4) (or x1 x5)) (or (and x1 x1) (or x4 x3)))) (or (or (and (not x6) (not x6)) (and (not x1) (or x3 x6))) (not (not (and x4 x0))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and (and (not (not (and (or (and x6 x6) (and x4 x4)) (or (or x2 x1) (or x0 x2))))) (and (and (not (or (and x0 x5) (or x2 x4))) (not (or (not x1) (not x1)))) (or (and (and (not x1) (not x3)) (not (or x4 x6))) (or (or (or x2 x6) (or x3 x4)) (and (and x3 x3) (or x0 x1)))))) (or (not (not (or (not (not x4)) (and (or x6 x0) (or x2 x0))))) (or (not (and (and (and x1 x3) (not x4)) (not (and x0 x1)))) (or (and (or (or x6 x4) (or x0 x6)) (or (or x6 x4) (not x4))) (and (not (or x5 x3)) (and (or x2 x2) (not x5)))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (or (not (or (or (or (or x1 x4) (and x3 x2)) (or (or x5 x1) (or x6 x2))) (or (not (and x3 x5)) (or (and x0 x1) (not x6))))) (and (and (and (or (and x3 x3) (or x2 x5)) (not (and x0 x4))) (not (not (not x4)))) (or (and (or (or x2 x1) (and x2 x2)) (not (or x1 x4))) (not (and (not x1) (and x0 x2)))))) (not (or (not (and (and (not x1) (and x3 x4)) (and (not x6) (or x6 x1)))) (not (not (and (or x2 x2) (and x4 x6))))))) (not (or (and (and (not (and (or x6 x5) (and x5 x2))) (not (or (not x4) (or x6 x1)))) (or (or (and (not x0) (not x4)) (or (and x4 x5) (not x4))) (or (and (or x6 x1) (and x3 x6)) (or (not x6) (or x4 x1))))) (not (or (and (and (or x2 x6) (not x3)) (or (or x3 x6) (or x1 x4))) (not (and (not x5) (not x0))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_5.smt2 b/test/regress/regress1/push-pop/fuzz_5.smt2 new file mode 100644 index 000000000..a29fda6e1 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_5.smt2 @@ -0,0 +1,65 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (or (or (not (not (and (and x3 x0) (not x2)))) (and (not (not (and x1 x6))) (and (and (or x1 x4) (or x0 x3)) (or (or x0 x4) (or x3 x3))))) (and (and (not (not (or x5 x3))) (or (or (and x5 x1) (not x4)) (and (or x4 x3) (and x4 x5)))) (not (or (not (not x6)) (or (not x0) (not x6))))))) +(check-sat) +(push 1) +(assert (not (not (or (not (not (and (and x6 x1) (or x2 x1)))) (and (or (not (or x1 x0)) (or (not x1) (or x3 x6))) (or (not (and x3 x1)) (not (not x1)))))))) +(assert (or (not (not (or x4 x3))) (or (not (and x4 x4)) (not (or x3 x5))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (not (or (not (not (and (and (not (not (not x5))) (and (not (and x5 x4)) (not (or x1 x0)))) (not (and (or (or x2 x4) (not x4)) (or (and x3 x6) (and x6 x2))))))) (and (and (not (and (or (not (or x1 x2)) (not (or x6 x1))) (or (and (not x3) (or x3 x5)) (or (and x4 x4) (and x6 x6))))) (not (and (not (or (or x3 x2) (not x2))) (not (or (not x2) (not x6)))))) (or (not (or (not (not (or x4 x3))) (and (and (and x2 x6) (or x6 x5)) (or (or x1 x3) (and x2 x3))))) (or (and (and (or (and x6 x0) (and x5 x1)) (not (not x1))) (or (or (and x0 x2) (not x0)) (not (or x0 x5)))) (and (not (and (not x2) (not x2))) (not (or (not x3) (not x5)))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (and (and (and (or (not (not (and (not x1) (not x2)))) (not (and (not (and x0 x4)) (and (not x3) (or x5 x1))))) (or (or (and (or (and x3 x6) (and x3 x1)) (not (or x1 x4))) (and (or (not x5) (not x0)) (not (not x3)))) (or (and (and (or x6 x5) (and x5 x5)) (or (and x1 x6) (and x5 x6))) (or (and (or x5 x6) (or x5 x4)) (not (or x2 x0)))))) (or (and (and (and (or (or x4 x2) (or x5 x1)) (and (or x5 x0) (and x5 x5))) (not (and (not x5) (or x3 x1)))) (not (and (and (or x5 x1) (and x0 x2)) (not (and x6 x3))))) (and (not (or (not (or x2 x2)) (and (or x0 x2) (not x0)))) (not (or (not (not x3)) (not (and x4 x6))))))) (or (not (or (or (or (or (not x3) (or x0 x3)) (not (and x0 x6))) (or (and (or x2 x4) (or x2 x6)) (and (or x3 x0) (not x6)))) (and (or (and (or x1 x4) (not x3)) (and (not x2) (not x0))) (not (or (not x5) (not x2)))))) (not (or (not (or (or (and x3 x2) (or x3 x6)) (and (and x1 x2) (or x1 x6)))) (not (and (or (not x4) (not x2)) (not (and x0 x0)))))))) (or (not (and (or (not (and (and (or x3 x4) (and x4 x1)) (not (not x1)))) (not (not (not (or x0 x2))))) (and (not (or (and (or x6 x2) (not x5)) (and (and x6 x6) (or x6 x6)))) (and (and (or (or x2 x2) (or x2 x1)) (or (not x1) (and x4 x1))) (or (or (not x4) (and x5 x6)) (or (not x0) (not x2))))))) (not (not (not (or (not (and (or x0 x5) (and x4 x0))) (not (not (and x3 x3))))))))) (or (and (not (not (or (and (or (not (and x3 x2)) (not (and x2 x3))) (not (or (not x2) (and x4 x0)))) (or (and (and (not x3) (and x6 x5)) (or (and x3 x3) (or x5 x0))) (not (or (or x4 x5) (or x2 x1))))))) (or (or (or (not (not (not (or x4 x4)))) (and (not (or (or x0 x4) (and x1 x3))) (and (not (and x5 x4)) (or (not x5) (not x5))))) (or (or (not (or (and x3 x6) (and x6 x1))) (not (or (and x5 x1) (not x5)))) (and (or (or (not x4) (not x4)) (and (and x2 x2) (or x4 x0))) (and (not (or x5 x2)) (or (not x5) (or x3 x5)))))) (not (and (not (and (and (not x0) (not x3)) (not (or x2 x2)))) (and (or (or (and x4 x6) (not x1)) (and (not x4) (or x3 x6))) (or (and (or x0 x1) (and x1 x4)) (or (and x4 x2) (and x2 x0)))))))) (and (or (or (not (and (or (or (or x2 x2) (not x1)) (and (or x4 x3) (or x1 x3))) (or (or (or x4 x0) (not x2)) (or (and x1 x3) (or x2 x5))))) (and (or (and (and (and x3 x3) (and x3 x4)) (not (and x6 x3))) (not (or (or x6 x1) (or x1 x6)))) (or (or (or (not x2) (not x0)) (or (and x6 x6) (not x6))) (not (not (not x0)))))) (and (not (or (or (and (and x1 x1) (and x6 x2)) (or (not x2) (and x2 x2))) (and (not (or x0 x5)) (and (not x4) (not x4))))) (or (not (and (and (or x0 x3) (and x2 x6)) (not (not x0)))) (not (or (not (and x3 x3)) (or (not x5) (and x1 x6))))))) (not (or (or (and (not (not (not x4))) (and (and (not x3) (and x4 x3)) (not (or x4 x2)))) (or (not (or (and x2 x6) (or x5 x2))) (and (not (or x6 x6)) (not (not x0))))) (and (not (and (or (or x4 x3) (and x1 x4)) (and (or x1 x6) (or x0 x1)))) (or (or (and (or x5 x1) (not x3)) (or (not x0) (or x1 x5))) (or (and (or x3 x6) (not x0)) (or (not x2) (or x2 x4))))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (or (and (not (not x0)) (and (and x0 x1) (or x2 x1))) (not (and (not x4) (or x6 x0))))) +(assert (not (not (and (or (or (and (and (or x4 x6) (or x3 x1)) (not (and x4 x5))) (or (not (not x3)) (and (not x6) (and x3 x6)))) (and (and (not (not x0)) (not (and x5 x5))) (or (not (or x1 x0)) (and (and x2 x3) (not x6))))) (or (and (and (not (or x0 x2)) (and (not x4) (or x3 x1))) (not (or (not x6) (and x4 x4)))) (not (not (not (and x6 x2))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (and (and (or (and (or (or (or (or (and (and x1 x4) (or x0 x0)) (or (not x3) (or x1 x4))) (not (not (and x6 x0)))) (or (and (and (or x1 x4) (not x4)) (or (not x1) (or x1 x0))) (and (or (not x6) (and x5 x2)) (and (not x2) (not x1))))) (or (and (not (and (and x2 x2) (not x3))) (not (or (or x4 x2) (not x5)))) (not (not (or (or x1 x1) (and x0 x4)))))) (or (or (or (and (not (and x1 x6)) (and (and x6 x2) (and x3 x3))) (not (not (or x5 x4)))) (or (or (not (or x6 x4)) (or (not x0) (not x4))) (not (or (and x4 x4) (not x3))))) (or (or (not (not (or x3 x2))) (or (or (and x6 x0) (not x2)) (and (not x5) (or x6 x0)))) (or (not (and (and x2 x3) (not x6))) (or (not (and x0 x4)) (or (or x3 x6) (not x1))))))) (not (and (or (and (and (or (not x2) (or x0 x6)) (not (and x5 x4))) (not (not (not x1)))) (not (or (or (or x5 x0) (not x4)) (not (not x4))))) (and (and (or (not (not x0)) (not (or x0 x3))) (or (and (or x1 x4) (and x3 x5)) (not (not x1)))) (not (or (not (and x4 x2)) (and (and x0 x2) (not x2)))))))) (and (and (or (and (or (or (and (not x4) (or x6 x3)) (not (not x5))) (and (and (and x2 x0) (or x2 x2)) (not (and x0 x0)))) (or (not (or (and x3 x4) (and x4 x0))) (or (not (not x0)) (not (not x3))))) (not (and (and (or (and x0 x2) (or x4 x4)) (and (and x4 x6) (not x0))) (or (not (or x0 x3)) (or (not x1) (or x3 x1)))))) (not (not (not (not (not (not x0))))))) (and (or (or (not (and (not (or x6 x3)) (not (and x4 x0)))) (not (and (and (not x4) (and x1 x3)) (not (not x5))))) (not (not (or (or (not x4) (not x1)) (or (not x3) (not x4)))))) (and (or (and (and (not (and x4 x5)) (or (and x0 x5) (or x6 x1))) (and (and (and x0 x1) (not x1)) (or (not x5) (and x5 x2)))) (not (or (or (and x4 x4) (or x5 x4)) (not (or x0 x4))))) (not (and (not (and (or x3 x6) (and x1 x1))) (or (or (or x1 x6) (or x6 x0)) (or (or x6 x0) (not x2))))))))) (or (and (and (or (and (or (not (not (not x1))) (and (not (or x6 x0)) (and (not x1) (not x1)))) (or (or (not (or x2 x6)) (and (or x4 x1) (or x0 x1))) (or (and (and x0 x6) (or x6 x0)) (or (and x2 x3) (or x4 x1))))) (or (not (and (not (or x2 x3)) (not (or x2 x4)))) (or (not (not (not x2))) (not (or (or x1 x4) (and x6 x2)))))) (not (or (or (not (and (or x3 x1) (or x4 x5))) (not (or (or x6 x5) (and x1 x6)))) (and (and (or (or x4 x4) (and x6 x6)) (and (and x2 x5) (not x5))) (or (or (not x2) (and x5 x6)) (or (not x3) (and x5 x6))))))) (or (and (or (not (or (and (or x5 x6) (and x2 x5)) (or (and x5 x3) (or x1 x2)))) (and (or (and (or x1 x2) (or x6 x5)) (and (not x5) (not x2))) (not (and (not x5) (not x0))))) (or (and (and (and (not x5) (and x5 x0)) (or (or x6 x6) (not x2))) (and (not (or x6 x1)) (not (and x6 x4)))) (or (not (and (not x4) (and x5 x6))) (or (or (or x1 x2) (not x5)) (not (or x3 x5)))))) (not (and (not (and (and (not x4) (or x4 x6)) (not (not x1)))) (not (and (or (or x0 x4) (not x4)) (and (or x5 x2) (not x1)))))))) (or (not (not (not (not (or (and (or x1 x4) (or x1 x2)) (not (not x1))))))) (and (not (not (and (or (or (and x0 x2) (not x4)) (or (or x5 x0) (or x6 x3))) (or (or (or x1 x3) (not x5)) (and (not x5) (and x4 x0)))))) (or (not (not (and (or (or x4 x4) (and x1 x6)) (not (not x2))))) (not (or (not (and (or x4 x0) (and x5 x1))) (and (and (and x3 x0) (not x1)) (and (and x6 x0) (not x1))))))))))) +(assert (or (or (and (not (not (and (not x3) (or x3 x3)))) (or (or (not (or x1 x6)) (and (and x2 x6) (or x1 x0))) (or (not (and x5 x0)) (or (or x6 x0) (not x0))))) (or (or (not (and (and x5 x4) (not x5))) (or (or (or x4 x1) (and x4 x0)) (or (not x0) (or x5 x6)))) (not (or (or (or x3 x1) (or x3 x6)) (or (or x1 x5) (or x5 x6)))))) (or (not (or (or (and (not x2) (and x0 x0)) (or (or x2 x6) (and x5 x5))) (or (or (not x6) (and x2 x3)) (not (and x4 x4))))) (and (and (or (not (and x3 x5)) (or (and x6 x4) (and x6 x6))) (not (or (not x6) (and x1 x2)))) (not (not (and (and x0 x4) (and x1 x0)))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (not (and x6 x6)))) +(check-sat) +(pop 1) +(assert (not (or (or (or x6 x6) (or x1 x5)) (and (not x2) (and x2 x3))))) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_51.smt2 b/test/regress/regress1/push-pop/fuzz_51.smt2 new file mode 100644 index 000000000..f9bdb084f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_51.smt2 @@ -0,0 +1,36 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(check-sat) +(push 1) +(assert (not (and (or (and (and (or x0 x0) (or x0 x0)) (or (not x0) (and x0 x0))) (and (or (or x0 x0) (not x0)) (not (and x0 x0)))) (or (or (or (not x0) (or x0 x0)) (and (or x0 x0) (and x0 x0))) (or (or (not x0) (or x0 x0)) (not (or x0 x0))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (or (and (and (not (and (or (or (or (not (not x0)) (not (and x0 x0))) (or (not (and x0 x0)) (and (and x0 x0) (and x0 x0)))) (not (not (or (or x0 x0) (or x0 x0))))) (or (not (or (or (not x0) (not x0)) (not (or x0 x0)))) (not (not (and (and x0 x0) (and x0 x0))))))) (or (or (not (or (and (or (and x0 x0) (and x0 x0)) (not (or x0 x0))) (not (and (or x0 x0) (or x0 x0))))) (or (not (not (and (and x0 x0) (and x0 x0)))) (not (not (and (or x0 x0) (not x0)))))) (not (not (and (and (or (and x0 x0) (or x0 x0)) (and (or x0 x0) (not x0))) (not (not (or x0 x0)))))))) (and (or (or (or (and (and (not (and x0 x0)) (and (and x0 x0) (or x0 x0))) (or (and (not x0) (and x0 x0)) (and (not x0) (or x0 x0)))) (and (or (and (and x0 x0) (or x0 x0)) (or (or x0 x0) (and x0 x0))) (or (and (or x0 x0) (and x0 x0)) (or (and x0 x0) (not x0))))) (or (and (and (or (not x0) (not x0)) (and (not x0) (not x0))) (or (or (not x0) (and x0 x0)) (or (or x0 x0) (and x0 x0)))) (not (and (not (or x0 x0)) (not (not x0)))))) (or (not (not (or (not (or x0 x0)) (and (and x0 x0) (or x0 x0))))) (and (or (not (or (not x0) (or x0 x0))) (or (or (not x0) (or x0 x0)) (or (not x0) (or x0 x0)))) (and (not (or (not x0) (not x0))) (not (and (not x0) (or x0 x0))))))) (or (or (and (or (and (and (not x0) (and x0 x0)) (not (and x0 x0))) (not (not (not x0)))) (and (and (or (and x0 x0) (not x0)) (and (or x0 x0) (not x0))) (or (not (and x0 x0)) (not (and x0 x0))))) (and (or (or (not (not x0)) (and (not x0) (and x0 x0))) (not (or (and x0 x0) (or x0 x0)))) (not (and (not (not x0)) (not (and x0 x0)))))) (not (and (not (not (not (not x0)))) (or (not (not (or x0 x0))) (not (or (and x0 x0) (or x0 x0))))))))) (not (and (or (not (and (and (not (not (not x0))) (and (and (and x0 x0) (and x0 x0)) (and (not x0) (or x0 x0)))) (and (or (or (and x0 x0) (not x0)) (and (not x0) (not x0))) (or (not (or x0 x0)) (and (or x0 x0) (or x0 x0)))))) (not (and (or (or (and (and x0 x0) (not x0)) (and (not x0) (and x0 x0))) (or (not (and x0 x0)) (not (or x0 x0)))) (and (and (or (not x0) (and x0 x0)) (and (and x0 x0) (and x0 x0))) (and (or (or x0 x0) (or x0 x0)) (or (and x0 x0) (or x0 x0))))))) (and (or (and (and (or (and (and x0 x0) (not x0)) (or (and x0 x0) (not x0))) (and (and (not x0) (and x0 x0)) (not (or x0 x0)))) (or (and (or (and x0 x0) (and x0 x0)) (not (or x0 x0))) (not (or (and x0 x0) (or x0 x0))))) (and (or (or (and (or x0 x0) (or x0 x0)) (not (not x0))) (and (not (and x0 x0)) (not (not x0)))) (and (not (and (not x0) (not x0))) (and (or (and x0 x0) (and x0 x0)) (or (or x0 x0) (and x0 x0)))))) (and (and (or (not (not (and x0 x0))) (or (or (and x0 x0) (not x0)) (or (not x0) (or x0 x0)))) (not (or (and (not x0) (and x0 x0)) (or (and x0 x0) (or x0 x0))))) (not (or (or (not (not x0)) (or (not x0) (not x0))) (not (not (and x0 x0))))))))))) +(check-sat) +(push 1) +(assert (and (not (and (not (not (not x0))) (or (not (not x0)) (and (not x0) (or x0 x0))))) (or (not (not (or (not x0) (or x0 x0)))) (and (and (or (or x0 x0) (not x0)) (not (and x0 x0))) (not (or (not x0) (not x0))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (not (or (not (or (and (and (not (or (not (not x0)) (not (not x0)))) (and (not (not (or x0 x0))) (or (and (or x0 x0) (and x0 x0)) (and (or x0 x0) (and x0 x0))))) (or (not (or (and (not x0) (not x0)) (or (not x0) (not x0)))) (and (and (or (not x0) (and x0 x0)) (or (or x0 x0) (and x0 x0))) (not (not (and x0 x0)))))) (not (not (and (or (not (and x0 x0)) (or (or x0 x0) (and x0 x0))) (not (not (and x0 x0)))))))) (not (or (and (or (and (not (or (not x0) (and x0 x0))) (and (or (and x0 x0) (and x0 x0)) (not (or x0 x0)))) (or (and (or (not x0) (not x0)) (not (and x0 x0))) (or (and (and x0 x0) (not x0)) (and (or x0 x0) (and x0 x0))))) (and (or (and (and (or x0 x0) (not x0)) (or (or x0 x0) (and x0 x0))) (not (or (and x0 x0) (and x0 x0)))) (not (or (not (not x0)) (or (not x0) (not x0)))))) (or (or (or (and (or (and x0 x0) (not x0)) (not (not x0))) (and (not (or x0 x0)) (and (not x0) (not x0)))) (or (not (and (and x0 x0) (and x0 x0))) (and (not (not x0)) (and (or x0 x0) (not x0))))) (or (and (not (not (not x0))) (and (and (and x0 x0) (not x0)) (or (and x0 x0) (and x0 x0)))) (or (and (not (or x0 x0)) (and (and x0 x0) (not x0))) (or (not (not x0)) (and (or x0 x0) (or x0 x0))))))))))) +(check-sat) +(push 1) +(assert (and (or (not (not (and (and (not (not (not (and x0 x0)))) (not (not (and (or x0 x0) (not x0))))) (and (or (or (and (or x0 x0) (or x0 x0)) (or (not x0) (or x0 x0))) (and (and (and x0 x0) (not x0)) (or (not x0) (or x0 x0)))) (or (not (and (and x0 x0) (not x0))) (not (not (not x0)))))))) (or (and (and (and (or (or (not (not x0)) (and (or x0 x0) (or x0 x0))) (and (and (and x0 x0) (or x0 x0)) (and (not x0) (or x0 x0)))) (or (or (not (not x0)) (or (or x0 x0) (and x0 x0))) (or (or (and x0 x0) (or x0 x0)) (not (and x0 x0))))) (not (or (not (or (and x0 x0) (not x0))) (and (and (not x0) (not x0)) (or (not x0) (or x0 x0)))))) (not (and (and (not (and (or x0 x0) (not x0))) (and (or (or x0 x0) (or x0 x0)) (or (and x0 x0) (or x0 x0)))) (or (or (not (not x0)) (and (not x0) (and x0 x0))) (and (and (or x0 x0) (or x0 x0)) (and (and x0 x0) (not x0))))))) (not (or (or (and (not (and (and x0 x0) (and x0 x0))) (or (or (or x0 x0) (or x0 x0)) (and (and x0 x0) (not x0)))) (not (not (or (or x0 x0) (or x0 x0))))) (not (or (or (or (and x0 x0) (not x0)) (not (or x0 x0))) (or (not (or x0 x0)) (and (and x0 x0) (or x0 x0))))))))) (or (or (and (not (not (not (and (or (or x0 x0) (not x0)) (and (not x0) (not x0)))))) (or (or (not (and (not (and x0 x0)) (not (and x0 x0)))) (not (not (not (or x0 x0))))) (or (and (or (or (or x0 x0) (not x0)) (or (and x0 x0) (not x0))) (or (and (not x0) (and x0 x0)) (not (not x0)))) (not (or (and (not x0) (and x0 x0)) (and (not x0) (and x0 x0))))))) (or (not (and (and (or (or (or x0 x0) (or x0 x0)) (not (not x0))) (or (and (not x0) (and x0 x0)) (not (and x0 x0)))) (or (or (not (not x0)) (or (and x0 x0) (and x0 x0))) (not (and (not x0) (and x0 x0)))))) (or (and (or (not (and (and x0 x0) (and x0 x0))) (not (or (not x0) (or x0 x0)))) (and (not (and (or x0 x0) (or x0 x0))) (or (or (not x0) (or x0 x0)) (or (and x0 x0) (or x0 x0))))) (not (or (and (or (not x0) (and x0 x0)) (and (and x0 x0) (or x0 x0))) (not (and (or x0 x0) (and x0 x0)))))))) (not (or (and (or (or (or (and (or x0 x0) (and x0 x0)) (and (not x0) (or x0 x0))) (and (or (or x0 x0) (not x0)) (or (or x0 x0) (and x0 x0)))) (not (or (and (or x0 x0) (or x0 x0)) (or (or x0 x0) (or x0 x0))))) (or (not (and (and (or x0 x0) (or x0 x0)) (or (and x0 x0) (not x0)))) (and (not (and (or x0 x0) (not x0))) (and (and (or x0 x0) (and x0 x0)) (and (not x0) (not x0)))))) (and (not (or (or (or (and x0 x0) (not x0)) (or (not x0) (or x0 x0))) (and (and (not x0) (not x0)) (not (not x0))))) (not (or (not (and (not x0) (or x0 x0))) (or (or (not x0) (and x0 x0)) (not (and x0 x0))))))))))) +(assert (or (not (and (or x0 x0) (or x0 x0))) (or (not (or x0 x0)) (not (not x0))))) +(assert (not (and (not (and (or (and (or x0 x0) (and x0 x0)) (not (and x0 x0))) (not (not (or x0 x0))))) (and (and (not (or (not x0) (not x0))) (and (or (and x0 x0) (or x0 x0)) (and (not x0) (not x0)))) (or (and (and (and x0 x0) (and x0 x0)) (or (not x0) (not x0))) (and (and (or x0 x0) (or x0 x0)) (or (not x0) (not x0)))))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_52.smt2 b/test/regress/regress1/push-pop/fuzz_52.smt2 new file mode 100644 index 000000000..2ab146602 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_52.smt2 @@ -0,0 +1,47 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(assert (not (and (not x3) (or x2 x1)))) +(assert (or (not (or (and (not (or (or (or (not x2) (not x7)) (and (or x7 x4) (or x6 x7))) (not (not (or x6 x4))))) (not (or (or (and (or x1 x5) (and x4 x7)) (or (and x4 x6) (and x0 x0))) (not (and (and x5 x7) (and x0 x5)))))) (and (or (not (and (not (or x1 x7)) (and (or x1 x5) (and x6 x1)))) (or (and (not (not x5)) (not (not x5))) (and (or (or x0 x5) (and x1 x3)) (or (or x0 x6) (and x2 x7))))) (not (or (not (and (and x0 x4) (not x2))) (not (and (or x1 x3) (not x7)))))))) (not (and (and (not (or (or (or (not x7) (and x0 x5)) (not (or x4 x3))) (or (and (and x3 x1) (and x7 x4)) (or (and x5 x4) (not x6))))) (not (not (or (or (not x1) (or x7 x1)) (and (or x1 x5) (or x3 x1)))))) (or (and (not (and (and (and x2 x7) (or x4 x5)) (not (or x6 x4)))) (not (and (or (or x5 x2) (and x4 x3)) (or (or x4 x0) (and x0 x1))))) (not (and (and (and (not x1) (or x2 x1)) (not (or x7 x6))) (not (or (and x4 x4) (not x2)))))))))) +(assert (and (or (and (not (or (and (and (or (not x0) (and x1 x7)) (and (not x0) (or x4 x5))) (or (or (and x6 x7) (or x3 x3)) (or (or x2 x2) (and x5 x6)))) (not (not (and (or x3 x6) (and x6 x0)))))) (and (not (not (not (not (and x7 x6))))) (or (not (or (not (or x7 x4)) (or (or x7 x4) (or x4 x2)))) (not (and (and (not x3) (or x3 x1)) (not (or x5 x4))))))) (and (and (and (not (not (and (not x5) (and x7 x5)))) (not (not (and (not x4) (and x5 x6))))) (or (not (and (and (or x4 x3) (not x6)) (and (and x2 x5) (or x5 x2)))) (or (and (or (and x0 x1) (not x3)) (or (not x4) (or x0 x2))) (not (or (not x6) (not x0)))))) (not (not (or (and (and (and x3 x0) (not x0)) (not (not x3))) (not (and (and x5 x3) (not x7)))))))) (and (or (not (and (or (and (and (not x0) (or x4 x2)) (or (and x3 x0) (or x6 x0))) (or (or (not x6) (not x7)) (not (and x5 x0)))) (and (not (or (and x1 x5) (not x2))) (or (not (and x3 x4)) (and (and x2 x0) (and x1 x6)))))) (not (and (or (and (and (or x5 x5) (not x2)) (or (or x6 x7) (or x7 x5))) (not (and (and x0 x4) (or x5 x1)))) (and (or (or (not x0) (or x7 x2)) (or (not x3) (and x1 x0))) (or (not (not x3)) (and (or x0 x0) (and x0 x2))))))) (or (or (and (and (and (and (not x5) (and x7 x6)) (and (and x0 x2) (or x3 x4))) (not (and (not x7) (or x3 x1)))) (and (not (or (or x4 x3) (or x5 x1))) (not (and (and x0 x0) (or x7 x6))))) (not (and (not (not (and x2 x6))) (and (and (or x3 x6) (or x4 x3)) (or (and x2 x1) (and x7 x6)))))) (and (not (and (and (not (not x3)) (not (or x3 x1))) (not (or (or x2 x3) (not x0))))) (not (or (not (or (and x2 x1) (or x4 x2))) (not (or (not x4) (or x2 x7)))))))))) +(check-sat) +(push 1) +(assert (not (not (not (or (and (or (and x6 x5) (or x6 x7)) (or (not x2) (not x7))) (or (or (and x6 x3) (and x7 x7)) (or (and x6 x4) (or x0 x6)))))))) +(assert (not (or (not (and (not (or (not (and (or x0 x1) (not x1))) (or (or (and x3 x1) (and x2 x0)) (or (and x1 x3) (or x7 x3))))) (or (or (and (and (not x2) (not x0)) (and (not x4) (not x2))) (not (and (not x6) (not x7)))) (not (not (not (or x0 x2))))))) (and (and (or (not (or (and (or x4 x2) (and x6 x4)) (and (or x4 x3) (and x1 x6)))) (and (or (or (not x5) (and x1 x5)) (and (and x6 x0) (not x0))) (or (and (or x5 x2) (and x7 x4)) (not (not x6))))) (or (and (or (not (or x7 x4)) (and (and x3 x3) (or x4 x0))) (not (not (or x0 x3)))) (or (not (not (and x3 x2))) (or (not (or x1 x6)) (or (and x5 x6) (and x6 x6)))))) (or (and (and (or (and (or x3 x7) (not x4)) (not (not x0))) (or (not (and x4 x3)) (not (and x6 x1)))) (not (not (or (and x1 x5) (and x7 x3))))) (and (or (or (not (and x4 x0)) (or (and x5 x0) (or x5 x4))) (or (and (and x6 x7) (not x4)) (and (not x0) (and x3 x1)))) (or (not (or (not x6) (or x2 x4))) (or (or (or x1 x5) (not x1)) (or (not x5) (and x3 x6)))))))))) +(assert (not (or (not (not x4)) (and (and x5 x0) (and x6 x7))))) +(assert (not (not (and (and (or (not x5) (or x4 x5)) (or (and x7 x5) (or x7 x0))) (not (not (and x1 x7))))))) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (or x0 x6)) (not (and x1 x7)))) +(check-sat) +(push 1) +(assert (or (and (not x7) (not x4)) (or (not x3) (or x7 x7)))) +(assert (not (and (or (and (not (or (and (not (and (and x0 x0) (and x3 x3))) (and (and (not x3) (or x2 x5)) (not (not x0)))) (not (not (or (or x3 x5) (not x4)))))) (and (not (not (not (or (or x3 x4) (or x3 x6))))) (not (or (or (or (or x5 x1) (not x2)) (and (not x3) (and x1 x2))) (not (and (not x5) (and x1 x5))))))) (not (and (or (not (not (or (or x3 x0) (not x2)))) (and (or (or (and x2 x6) (or x5 x6)) (and (or x7 x7) (not x3))) (not (not (and x0 x7))))) (or (or (and (or (not x7) (or x0 x0)) (and (and x2 x4) (not x1))) (not (or (not x3) (and x7 x2)))) (and (not (and (or x4 x0) (not x4))) (not (or (or x5 x7) (or x5 x3)))))))) (or (not (not (and (or (and (not (or x0 x2)) (not (and x4 x1))) (or (not (and x4 x3)) (and (or x4 x0) (not x0)))) (and (or (or (not x7) (and x7 x4)) (and (and x3 x3) (or x3 x4))) (or (or (or x7 x7) (or x5 x7)) (not (not x3))))))) (not (not (or (not (not (and (and x3 x6) (not x5)))) (and (and (or (or x6 x2) (and x2 x6)) (not (or x6 x0))) (not (and (or x6 x6) (not x1))))))))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (or (and (or (not x6) (and x4 x4)) (not (and x3 x3))) (and (not (or x2 x4)) (and (not x1) (or x4 x6)))))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_5_1.smt2 b/test/regress/regress1/push-pop/fuzz_5_1.smt2 new file mode 100644 index 000000000..05414230a --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_5_1.smt2 @@ -0,0 +1,83 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(assert (<= (+ (* 27 x2 ) (* 30 x4 ) ) (- 46)) ) +(assert (or (not (>= (+ (* (- 16) x0 ) (* (- 10) x4 ) (* 21 x3 ) (* (- 46) x0 ) (* 29 x0 ) (* 41 x4 ) (* 32 x0 ) (* 33 x2 ) (* (- 37) x1 ) (* 36 x3 ) (* 18 x3 ) ) (- 34))) (<= (+ (* (- 40) x2 ) (* (- 3) x1 ) (* (- 44) x4 ) (* (- 45) x1 ) (* 20 x1 ) (* 48 x1 ) (* 28 x1 ) (* (- 27) x3 ) (* 35 x4 ) ) (- 45)) )) +(assert (or (not (= (+ (* (- 41) x2 ) (* 28 x2 ) (* (- 8) x3 ) (* 27 x0 ) (* (- 19) x2 ) (* (- 7) x4 ) ) (- 13))) (< (+ (* (- 26) x3 ) (* (- 44) x4 ) (* 14 x2 ) (* (- 27) x4 ) (* 37 x0 ) (* (- 32) x3 ) (* (- 46) x1 ) (* 23 x2 ) ) 15) )) +(assert (not (>= (+ (* 31 x1 ) (* (- 15) x1 ) (* 25 x2 ) (* 27 x3 ) (* 23 x1 ) ) (- 48))) ) +(assert (or (< (+ (* (- 38) x2 ) (* 15 x3 ) (* 9 x3 ) (* 25 x0 ) (* 37 x0 ) (* 39 x2 ) (* 41 x1 ) (* (- 18) x3 ) ) (- 26)) (not (> (+ (* 15 x2 ) (* 18 x1 ) (* 35 x3 ) (* 20 x1 ) (* 31 x1 ) (* (- 25) x2 ) (* 30 x3 ) (* 26 x1 ) (* (- 37) x2 ) (* 27 x4 ) (* (- 32) x0 ) ) 16)) )) +(assert (or (not (= (+ (* 27 x3 ) (* (- 50) x1 ) (* (- 28) x2 ) ) (- 30))) (not (>= (+ (* (- 50) x3 ) (* (- 15) x0 ) (* 15 x3 ) (* 19 x2 ) ) (- 8))) )) +(assert (or (>= (+ (* 4 x1 ) (* 27 x3 ) (* 15 x3 ) (* (- 39) x4 ) (* (- 45) x4 ) (* 38 x3 ) (* 33 x4 ) (* 40 x1 ) (* (- 26) x2 ) (* 44 x1 ) ) (- 39)) (> (+ (* 4 x0 ) (* (- 26) x3 ) (* (- 24) x2 ) ) (- 40)) )) +(assert (not (> (+ (* (- 39) x1 ) (* 32 x4 ) ) 19)) ) +(assert (or (= (+ (* (- 13) x1 ) (* (- 16) x3 ) ) 33) (not (> (+ (* 47 x4 ) (* (- 3) x4 ) (* (- 49) x3 ) (* (- 15) x1 ) (* (- 39) x1 ) (* 20 x1 ) (* 44 x4 ) (* 30 x4 ) (* 5 x1 ) (* 49 x4 ) (* 23 x0 ) ) 41)) )) +(assert (or (< (+ (* 41 x0 ) (* (- 50) x1 ) (* 41 x3 ) (* (- 37) x4 ) (* 27 x4 ) (* (- 32) x4 ) (* (- 43) x3 ) (* (- 46) x3 ) (* (- 28) x3 ) (* 31 x4 ) (* 45 x2 ) ) 31) (not (= (+ (* (- 19) x0 ) (* (- 30) x4 ) (* (- 24) x4 ) (* (- 27) x1 ) (* 2 x1 ) (* 28 x4 ) (* (- 40) x2 ) ) 5)) (>= (+ (* 19 x2 ) (* (- 20) x0 ) (* 35 x1 ) (* (- 29) x2 ) (* (- 5) x0 ) (* (- 49) x1 ) (* (- 9) x4 ) (* 3 x0 ) (* (- 36) x3 ) (* 27 x0 ) ) (- 13)) )) +(assert (or (> (+ (* 42 x4 ) (* 44 x4 ) (* (- 4) x3 ) (* 38 x3 ) (* (- 43) x2 ) ) (- 25)) (> (+ (* (- 16) x1 ) (* 5 x4 ) (* (- 6) x2 ) ) 11) )) +(assert (or (> (+ (* 1 x3 ) (* (- 10) x4 ) (* 20 x1 ) (* 20 x4 ) (* (- 26) x4 ) ) (- 33)) (< (+ (* 40 x2 ) (* (- 35) x2 ) ) (- 2)) )) +(assert (or (<= (+ (* (- 5) x4 ) (* (- 35) x3 ) (* 45 x3 ) (* 44 x0 ) (* (- 31) x1 ) (* (- 50) x4 ) (* 20 x1 ) (* 8 x0 ) (* (- 11) x1 ) (* (- 40) x3 ) (* 27 x0 ) ) 2) (= (+ (* (- 5) x1 ) (* (- 16) x2 ) (* (- 34) x2 ) (* (- 47) x4 ) (* 20 x3 ) (* 48 x3 ) ) 14) )) +(assert (or (not (< (+ (* 17 x2 ) (* (- 32) x4 ) ) (- 43))) (= (+ (* (- 17) x1 ) (* 30 x4 ) (* 20 x2 ) (* (- 1) x2 ) (* 5 x1 ) (* (- 14) x2 ) (* 2 x3 ) (* 6 x3 ) (* 24 x1 ) (* 23 x3 ) (* 0 x4 ) ) (- 14)) (< (+ (* 27 x1 ) (* 48 x2 ) (* 4 x1 ) (* 40 x3 ) (* (- 29) x4 ) (* 14 x3 ) (* 19 x2 ) (* (- 10) x4 ) (* (- 21) x0 ) (* (- 35) x4 ) ) (- 13)) )) +(assert (or (<= (+ (* 7 x3 ) (* 13 x3 ) (* (- 19) x0 ) ) (- 10)) (= (+ (* (- 37) x3 ) (* (- 25) x2 ) (* (- 33) x1 ) (* (- 41) x4 ) (* 10 x2 ) (* (- 6) x1 ) ) (- 9)) (> (+ (* (- 1) x3 ) (* 15 x1 ) (* (- 35) x2 ) (* 30 x4 ) (* (- 9) x3 ) (* 21 x2 ) (* 44 x1 ) ) (- 17)) )) +(check-sat) +(push 1) +(assert (<= (+ (* 5 x2 ) (* 44 x2 ) (* 36 x3 ) (* 3 x0 ) (* 16 x3 ) ) 48) ) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (not (<= (+ (* (- 39) x4 ) (* (- 40) x1 ) ) (- 45))) ) +(assert (= (+ (* 35 x3 ) (* 20 x1 ) (* (- 49) x4 ) (* (- 32) x3 ) (* 33 x3 ) (* 4 x1 ) (* (- 34) x4 ) (* 0 x4 ) (* (- 50) x3 ) ) 42) ) +(assert (or (> (+ (* 2 x3 ) (* (- 33) x4 ) (* 15 x1 ) (* 34 x4 ) (* (- 3) x2 ) (* (- 16) x1 ) (* (- 14) x3 ) (* 39 x2 ) ) 21) (not (<= (+ (* 39 x2 ) (* 22 x2 ) (* (- 50) x0 ) (* (- 23) x0 ) (* (- 48) x3 ) (* (- 31) x3 ) (* 9 x1 ) (* (- 23) x1 ) (* 27 x1 ) (* 29 x3 ) ) (- 26))) (not (<= (+ (* 15 x0 ) (* 26 x1 ) (* 11 x0 ) (* 24 x4 ) (* (- 9) x3 ) (* (- 5) x2 ) (* 4 x3 ) (* 24 x2 ) (* (- 5) x3 ) (* 16 x3 ) (* 31 x2 ) ) 43)) )) +(assert (or (>= (+ (* 27 x4 ) (* 36 x1 ) (* 27 x4 ) (* (- 18) x0 ) (* (- 1) x4 ) (* 44 x1 ) (* (- 45) x2 ) (* 38 x4 ) (* (- 39) x2 ) (* (- 30) x2 ) ) (- 41)) (not (< (+ (* (- 18) x3 ) (* 48 x1 ) (* 14 x3 ) (* (- 28) x2 ) (* 46 x1 ) (* 38 x4 ) (* (- 26) x0 ) ) (- 30))) )) +(assert (or (= (+ (* (- 1) x4 ) (* 46 x0 ) (* 19 x3 ) (* 24 x3 ) (* (- 43) x1 ) (* 14 x2 ) (* (- 7) x2 ) (* 35 x2 ) ) 9) (not (< (+ (* (- 34) x3 ) (* 18 x1 ) (* 11 x2 ) (* (- 33) x0 ) (* 45 x4 ) (* (- 27) x0 ) (* 42 x2 ) (* (- 40) x1 ) (* (- 10) x2 ) ) 34)) )) +(assert (or (not (>= (+ (* 15 x1 ) (* (- 19) x1 ) (* 34 x4 ) (* 9 x4 ) (* (- 25) x2 ) (* (- 5) x3 ) (* 15 x1 ) (* 27 x4 ) (* 49 x2 ) (* (- 41) x1 ) ) 42)) (not (< (+ (* (- 43) x4 ) (* (- 38) x4 ) (* (- 3) x0 ) (* (- 43) x3 ) ) 15)) )) +(assert (or (>= (+ (* 18 x4 ) (* 19 x4 ) (* (- 13) x0 ) (* 30 x1 ) (* 48 x4 ) (* 17 x1 ) (* 25 x0 ) (* 33 x2 ) (* 6 x1 ) (* (- 24) x1 ) (* (- 24) x0 ) ) (- 25)) (not (<= (+ (* 25 x1 ) (* (- 26) x2 ) (* (- 37) x1 ) (* 2 x4 ) (* (- 40) x2 ) (* (- 30) x1 ) (* 6 x2 ) (* (- 25) x0 ) ) 25)) )) +(assert (or (>= (+ (* 7 x1 ) (* 46 x2 ) (* 40 x0 ) (* (- 29) x2 ) (* 30 x0 ) (* (- 46) x3 ) (* 0 x4 ) (* (- 1) x2 ) (* 1 x4 ) ) (- 39)) (not (<= (+ (* (- 8) x2 ) (* 29 x0 ) (* (- 15) x4 ) (* 40 x4 ) (* 25 x0 ) (* (- 16) x2 ) (* (- 15) x3 ) (* (- 2) x4 ) ) (- 42))) )) +(assert (or (not (<= (+ (* (- 19) x3 ) (* (- 37) x4 ) (* 47 x4 ) (* 8 x4 ) (* (- 37) x2 ) (* 34 x0 ) (* 26 x4 ) (* (- 7) x0 ) ) (- 31))) (> (+ (* 44 x3 ) (* (- 45) x3 ) (* 11 x2 ) (* (- 28) x2 ) ) 20) (not (> (+ (* 43 x3 ) (* (- 5) x3 ) (* 4 x0 ) (* (- 6) x3 ) (* 5 x2 ) (* 14 x1 ) (* (- 49) x3 ) ) (- 43))) )) +(check-sat) +(pop 1) +(assert (or (>= (+ (* 16 x3 ) (* (- 8) x1 ) (* 8 x3 ) (* (- 2) x0 ) (* 30 x3 ) ) (- 9)) (not (>= (+ (* 30 x1 ) (* (- 44) x0 ) (* 11 x2 ) (* 21 x0 ) ) (- 36))) (not (< (+ (* 44 x2 ) (* 33 x2 ) (* 15 x1 ) (* (- 41) x4 ) (* 40 x0 ) (* 32 x2 ) (* (- 45) x3 ) (* (- 19) x2 ) (* (- 10) x2 ) (* 26 x2 ) (* (- 2) x0 ) ) (- 16))) )) +(assert (or (not (< (+ (* 6 x0 ) (* (- 5) x2 ) (* 24 x1 ) (* (- 26) x3 ) (* 28 x2 ) (* 2 x3 ) ) (- 30))) (<= (+ (* (- 2) x2 ) (* (- 3) x1 ) ) (- 10)) (not (> (+ (* (- 41) x4 ) (* 20 x3 ) (* (- 46) x0 ) ) (- 4))) )) +(assert (not (> (+ (* (- 26) x0 ) (* 4 x2 ) (* 22 x4 ) (* (- 24) x3 ) (* (- 6) x4 ) (* 32 x1 ) (* (- 21) x0 ) (* 35 x4 ) ) 40)) ) +(check-sat) +(push 1) +(assert (or (not (= (+ (* (- 23) x0 ) (* 30 x0 ) (* 6 x0 ) (* (- 47) x3 ) (* (- 46) x4 ) (* 23 x3 ) (* 17 x0 ) ) (- 18))) (< (+ (* 24 x4 ) (* (- 45) x1 ) (* 9 x0 ) (* (- 39) x3 ) (* 49 x2 ) (* (- 21) x1 ) (* 8 x3 ) (* 44 x3 ) (* (- 2) x0 ) (* (- 32) x2 ) ) (- 46)) )) +(assert (or (not (< (+ (* 29 x1 ) (* 8 x4 ) (* (- 50) x2 ) (* 31 x4 ) (* (- 11) x1 ) (* (- 44) x0 ) (* 47 x2 ) (* 28 x0 ) (* (- 19) x3 ) ) (- 14))) (not (>= (+ (* (- 23) x2 ) (* 41 x2 ) (* (- 26) x1 ) (* (- 2) x0 ) (* 7 x0 ) (* (- 13) x2 ) (* 36 x0 ) (* (- 50) x2 ) (* 45 x2 ) ) 41)) )) +(check-sat) +(pop 1) +(assert (or (= (+ (* (- 37) x0 ) (* 17 x4 ) (* 12 x2 ) (* (- 9) x4 ) (* (- 3) x0 ) (* 46 x0 ) (* 28 x0 ) (* 24 x0 ) (* (- 30) x0 ) (* (- 46) x1 ) (* (- 22) x2 ) ) (- 50)) (> (+ (* 47 x0 ) (* (- 16) x2 ) (* 4 x4 ) (* (- 39) x2 ) (* (- 11) x1 ) (* 18 x0 ) ) 31) (not (> (+ (* (- 39) x3 ) (* 33 x3 ) ) 35)) )) +(assert (or (> (+ (* (- 50) x2 ) (* 17 x2 ) (* (- 48) x0 ) (* (- 32) x4 ) (* (- 2) x2 ) (* (- 14) x2 ) (* 44 x4 ) (* 34 x1 ) ) 12) (not (>= (+ (* (- 5) x4 ) (* 38 x0 ) (* (- 24) x4 ) (* 35 x3 ) (* 33 x4 ) (* (- 47) x3 ) (* 8 x0 ) (* (- 9) x0 ) (* (- 16) x2 ) (* (- 1) x1 ) (* (- 15) x0 ) ) (- 12))) (not (< (+ (* 45 x1 ) (* 0 x0 ) (* 36 x0 ) (* 15 x0 ) (* 26 x4 ) (* (- 40) x3 ) ) 11)) )) +(assert (not (> (+ (* (- 4) x0 ) (* 47 x1 ) (* (- 13) x0 ) (* 17 x4 ) (* (- 13) x4 ) (* (- 44) x4 ) (* (- 5) x3 ) (* (- 20) x3 ) (* 28 x2 ) ) 18)) ) +(assert (or (not (< (+ (* (- 18) x0 ) (* (- 48) x1 ) (* 37 x4 ) (* 46 x0 ) (* 11 x0 ) (* (- 33) x4 ) (* (- 5) x0 ) ) 35)) (>= (+ (* (- 13) x3 ) (* 36 x1 ) (* (- 7) x4 ) (* 37 x0 ) (* (- 37) x2 ) (* (- 42) x2 ) (* (- 11) x4 ) ) (- 9)) (= (+ (* 27 x2 ) (* 42 x1 ) (* (- 3) x1 ) (* (- 9) x4 ) (* 44 x2 ) (* (- 24) x3 ) (* (- 49) x3 ) (* 39 x0 ) (* 36 x0 ) (* 7 x4 ) ) (- 25)) )) +(assert (or (< (+ (* (- 27) x4 ) (* 43 x4 ) ) (- 22)) (not (>= (+ (* (- 36) x3 ) (* (- 47) x1 ) (* (- 30) x2 ) ) (- 1))) (> (+ (* (- 37) x1 ) (* (- 29) x4 ) (* 19 x1 ) (* 26 x3 ) (* (- 50) x3 ) (* 23 x1 ) (* 38 x2 ) (* 23 x4 ) (* 27 x3 ) (* 6 x0 ) ) 8) )) +(assert (or (not (<= (+ (* (- 25) x1 ) (* (- 46) x3 ) (* (- 11) x0 ) (* 6 x4 ) (* (- 30) x3 ) (* (- 7) x2 ) (* (- 30) x1 ) (* 35 x4 ) ) (- 4))) (not (<= (+ (* 8 x1 ) (* (- 27) x2 ) (* 32 x2 ) (* 39 x1 ) (* 21 x3 ) ) 21)) (< (+ (* (- 30) x0 ) (* 1 x3 ) (* (- 12) x2 ) (* 4 x1 ) (* (- 31) x1 ) (* 27 x2 ) (* 23 x1 ) (* 31 x2 ) ) 18) )) +(assert (or (< (+ (* (- 30) x1 ) (* 44 x2 ) (* (- 26) x2 ) (* 42 x0 ) ) 7) (not (= (+ (* (- 8) x3 ) (* (- 26) x0 ) (* 4 x1 ) (* 25 x0 ) ) 33)) )) +(assert (not (> (+ (* 27 x2 ) (* 11 x2 ) (* (- 12) x3 ) (* (- 9) x4 ) (* 28 x4 ) (* (- 46) x2 ) (* (- 24) x0 ) (* (- 15) x3 ) ) (- 41))) ) +(check-sat) +(push 1) +(assert (or (= (+ (* (- 49) x3 ) (* (- 15) x1 ) (* (- 43) x0 ) (* 20 x0 ) (* 48 x1 ) (* (- 41) x3 ) (* 23 x3 ) (* 29 x3 ) (* (- 29) x3 ) ) 46) (> (+ (* 29 x3 ) (* 34 x4 ) (* (- 33) x2 ) (* 33 x4 ) (* 9 x0 ) (* 26 x4 ) ) (- 4)) )) +(assert (not (< (+ (* (- 6) x1 ) (* 5 x2 ) (* (- 14) x2 ) (* (- 23) x1 ) (* (- 15) x4 ) (* 3 x2 ) (* (- 35) x0 ) (* 44 x0 ) ) 1)) ) +(assert (or (not (> (+ (* (- 37) x1 ) (* (- 18) x4 ) (* (- 19) x2 ) (* (- 37) x1 ) (* 17 x4 ) (* (- 43) x2 ) (* (- 24) x4 ) ) (- 7))) (>= (+ (* 46 x3 ) (* 8 x0 ) (* 45 x3 ) ) (- 46)) (not (<= (+ (* (- 32) x4 ) (* 30 x4 ) (* 30 x3 ) (* (- 15) x3 ) (* 14 x2 ) (* 28 x0 ) (* 7 x3 ) (* 8 x0 ) ) (- 14))) )) +(assert (or (not (>= (+ (* 45 x3 ) (* 3 x4 ) ) (- 8))) (not (< (+ (* (- 37) x0 ) (* (- 14) x1 ) (* 34 x4 ) (* 9 x4 ) (* (- 17) x2 ) ) (- 27))) )) +(assert (or (>= (+ (* (- 32) x1 ) (* (- 11) x4 ) (* 16 x0 ) (* 0 x0 ) (* 41 x1 ) (* 5 x3 ) (* (- 28) x4 ) (* 27 x3 ) (* (- 11) x3 ) (* (- 16) x3 ) ) (- 26)) (not (> (+ (* 18 x2 ) (* (- 19) x0 ) (* 4 x1 ) (* 45 x0 ) (* (- 41) x2 ) (* (- 18) x4 ) ) 26)) (>= (+ (* (- 13) x3 ) (* 15 x0 ) (* 33 x2 ) (* (- 50) x2 ) (* (- 43) x0 ) (* 1 x1 ) (* 29 x2 ) (* 11 x4 ) (* 21 x4 ) ) 42) )) +(assert (<= (+ (* 9 x4 ) (* (- 40) x3 ) (* (- 33) x1 ) (* 46 x1 ) ) (- 43)) ) +(assert (or (<= (+ (* 9 x1 ) (* 7 x3 ) (* 7 x0 ) (* 11 x3 ) (* 37 x0 ) (* 13 x4 ) (* (- 40) x4 ) (* (- 13) x2 ) (* (- 29) x3 ) (* 46 x1 ) (* 2 x1 ) ) 15) (= (+ (* 12 x3 ) (* 17 x1 ) (* (- 36) x4 ) (* (- 18) x1 ) (* 38 x1 ) (* 9 x1 ) (* (- 38) x1 ) ) (- 4)) (not (< (+ (* (- 36) x3 ) (* 11 x0 ) (* 46 x1 ) (* (- 31) x4 ) (* 25 x0 ) (* (- 50) x4 ) (* 40 x4 ) (* 41 x4 ) ) 7)) )) +(assert (>= (+ (* 12 x4 ) (* (- 24) x0 ) (* (- 11) x4 ) (* 3 x2 ) (* (- 38) x2 ) (* (- 48) x2 ) (* 5 x4 ) (* 33 x3 ) ) (- 23)) ) +(assert (> (+ (* 15 x3 ) (* 31 x1 ) (* 8 x1 ) ) (- 33)) ) +(assert (not (<= (+ (* (- 41) x4 ) (* 33 x4 ) (* (- 29) x2 ) (* (- 20) x1 ) (* (- 28) x0 ) ) (- 13))) ) +(assert (or (not (< (+ (* 23 x3 ) (* (- 29) x1 ) (* (- 23) x0 ) (* (- 7) x4 ) (* 21 x2 ) (* (- 21) x0 ) ) (- 33))) (not (< (+ (* 30 x3 ) (* (- 30) x2 ) (* (- 30) x3 ) (* 30 x2 ) (* (- 10) x2 ) (* (- 3) x3 ) (* (- 22) x4 ) (* (- 48) x0 ) (* (- 9) x3 ) (* (- 6) x4 ) ) (- 30))) (not (<= (+ (* 2 x2 ) (* (- 31) x4 ) ) 3)) )) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_5_2.smt2 b/test/regress/regress1/push-pop/fuzz_5_2.smt2 new file mode 100644 index 000000000..9c387d89f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_5_2.smt2 @@ -0,0 +1,91 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(assert (> (+ (* (- 32) x4 ) (* 46 x3 ) ) 21) ) +(assert (< (+ (* 12 x3 ) (* (- 7) x2 ) (* (- 7) x0 ) (* (- 49) x1 ) (* (- 32) x3 ) ) (- 17)) ) +(assert (or (not (>= (+ (* (- 10) x2 ) (* 37 x1 ) (* 33 x0 ) (* 33 x0 ) ) 29)) (not (<= (+ (* 25 x3 ) (* 32 x4 ) (* (- 27) x3 ) (* 13 x2 ) (* (- 22) x1 ) (* (- 8) x4 ) (* (- 1) x4 ) (* 9 x4 ) (* 1 x1 ) (* 40 x1 ) ) 41)) )) +(assert (not (= (+ (* (- 12) x1 ) (* 5 x3 ) (* 36 x4 ) (* (- 35) x0 ) (* 18 x0 ) ) (- 12))) ) +(assert (>= (+ (* (- 25) x4 ) (* (- 20) x4 ) (* 12 x2 ) (* 3 x1 ) (* (- 26) x3 ) (* (- 20) x2 ) (* (- 13) x2 ) (* 35 x0 ) (* 30 x0 ) ) (- 10)) ) +(assert (or (not (= (+ (* (- 48) x1 ) (* 25 x0 ) (* 13 x4 ) ) 24)) (not (> (+ (* (- 24) x0 ) (* 24 x1 ) ) (- 19))) )) +(assert (not (< (+ (* (- 12) x2 ) (* (- 25) x3 ) ) (- 32))) ) +(assert (not (<= (+ (* 28 x4 ) (* 11 x4 ) (* 0 x3 ) (* (- 22) x4 ) (* (- 37) x0 ) (* 2 x3 ) (* 39 x1 ) ) (- 24))) ) +(assert (or (not (>= (+ (* 34 x3 ) (* 36 x2 ) (* (- 39) x4 ) (* 33 x2 ) (* 39 x1 ) (* 22 x3 ) (* 9 x3 ) ) (- 17))) (not (= (+ (* 19 x1 ) (* (- 45) x3 ) (* 16 x1 ) (* (- 50) x1 ) (* (- 23) x1 ) ) (- 25))) )) +(assert (or (<= (+ (* 24 x3 ) (* (- 17) x1 ) ) 7) (= (+ (* (- 8) x1 ) (* 39 x1 ) (* (- 5) x1 ) (* 19 x4 ) (* (- 28) x1 ) (* (- 11) x4 ) ) 38) )) +(assert (< (+ (* 35 x4 ) (* (- 28) x3 ) (* (- 11) x0 ) (* 49 x3 ) (* 7 x2 ) (* 44 x3 ) (* (- 10) x4 ) (* (- 28) x4 ) (* (- 45) x1 ) (* 30 x4 ) (* (- 13) x1 ) ) (- 48)) ) +(assert (or (> (+ (* 28 x4 ) (* (- 16) x1 ) (* 47 x0 ) (* (- 25) x3 ) (* 6 x1 ) ) 26) (not (<= (+ (* 49 x4 ) (* (- 7) x2 ) (* (- 17) x3 ) (* 42 x0 ) (* (- 23) x1 ) (* (- 30) x4 ) (* 7 x0 ) (* (- 44) x3 ) (* 38 x2 ) (* (- 36) x1 ) ) (- 28))) )) +(assert (or (>= (+ (* (- 45) x3 ) (* (- 47) x2 ) (* (- 37) x2 ) (* 19 x2 ) ) 7) (= (+ (* (- 30) x4 ) (* (- 2) x1 ) (* (- 34) x1 ) (* 6 x2 ) (* (- 15) x2 ) (* (- 40) x4 ) (* (- 32) x1 ) ) (- 37)) )) +(assert (not (<= (+ (* 24 x1 ) (* 18 x0 ) (* (- 3) x2 ) (* 46 x2 ) (* (- 7) x4 ) (* (- 5) x4 ) ) 14)) ) +(assert (or (not (> (+ (* (- 17) x3 ) (* (- 40) x0 ) (* 41 x4 ) (* (- 41) x0 ) (* (- 17) x2 ) (* (- 28) x3 ) (* 4 x3 ) (* 19 x3 ) (* (- 15) x2 ) ) 18)) (<= (+ (* (- 12) x0 ) (* 21 x0 ) (* (- 12) x0 ) ) (- 22)) )) +(assert (or (not (> (+ (* (- 29) x3 ) (* (- 14) x4 ) (* (- 17) x0 ) (* 36 x4 ) (* 42 x2 ) ) (- 10))) (not (<= (+ (* (- 16) x2 ) (* (- 24) x1 ) (* (- 17) x1 ) (* (- 29) x4 ) (* 47 x1 ) (* 34 x4 ) (* 2 x3 ) ) (- 20))) )) +(assert (or (< (+ (* 19 x1 ) (* 40 x1 ) (* 3 x0 ) (* (- 3) x0 ) (* (- 50) x0 ) (* 5 x2 ) (* (- 9) x4 ) ) 31) (> (+ (* 33 x4 ) (* (- 50) x2 ) (* (- 15) x4 ) (* (- 1) x3 ) (* (- 10) x3 ) (* 41 x0 ) (* (- 42) x4 ) ) (- 38)) )) +(check-sat) +(push 1) +(assert (or (= (+ (* 36 x1 ) (* 23 x1 ) (* 24 x1 ) (* 38 x0 ) (* 3 x1 ) (* (- 14) x2 ) (* 28 x0 ) (* 37 x0 ) ) 33) (<= (+ (* 34 x4 ) (* 2 x4 ) (* (- 20) x1 ) (* 18 x3 ) (* 39 x3 ) (* (- 44) x0 ) (* 18 x1 ) (* (- 1) x0 ) (* (- 15) x3 ) ) (- 13)) (<= (+ (* (- 10) x2 ) (* (- 11) x0 ) (* 30 x4 ) (* 22 x3 ) (* (- 6) x0 ) (* 35 x3 ) (* 6 x4 ) (* 2 x2 ) ) (- 26)) )) +(assert (or (not (<= (+ (* (- 9) x0 ) (* (- 27) x4 ) (* 6 x3 ) ) 21)) (not (> (+ (* 18 x0 ) (* 42 x4 ) (* (- 7) x0 ) (* 6 x1 ) (* 26 x4 ) (* 38 x3 ) (* 10 x2 ) (* (- 41) x3 ) (* 37 x2 ) (* 30 x0 ) ) (- 41))) )) +(assert (or (not (= (+ (* 48 x1 ) (* (- 38) x3 ) (* (- 15) x3 ) (* (- 2) x2 ) (* (- 17) x2 ) (* 45 x3 ) (* 32 x4 ) (* 32 x1 ) (* (- 46) x3 ) (* (- 34) x4 ) ) 15)) (not (<= (+ (* 14 x1 ) (* 17 x0 ) (* (- 33) x2 ) ) 20)) (<= (+ (* 19 x2 ) (* (- 25) x0 ) ) 19) )) +(assert (or (not (>= (+ (* 29 x4 ) (* (- 28) x1 ) (* (- 23) x3 ) (* (- 50) x3 ) (* 43 x3 ) (* 31 x0 ) ) 7)) (not (< (+ (* 21 x0 ) (* 11 x3 ) (* (- 24) x1 ) (* (- 2) x2 ) (* 2 x3 ) (* (- 37) x3 ) (* (- 34) x3 ) ) (- 38))) )) +(assert (not (<= (+ (* 29 x2 ) (* (- 38) x0 ) (* 17 x4 ) (* 31 x0 ) (* 44 x0 ) (* (- 10) x4 ) (* 18 x0 ) ) (- 49))) ) +(assert (< (+ (* 44 x4 ) (* (- 42) x4 ) (* 28 x0 ) (* 7 x0 ) (* (- 33) x0 ) (* 49 x4 ) (* 19 x1 ) ) (- 39)) ) +(assert (or (>= (+ (* 39 x3 ) (* (- 30) x4 ) (* 27 x4 ) (* 5 x4 ) (* (- 10) x2 ) (* 2 x1 ) (* (- 28) x4 ) (* (- 5) x2 ) ) 2) (= (+ (* 44 x1 ) (* (- 45) x1 ) (* 39 x3 ) (* (- 46) x1 ) (* (- 18) x0 ) (* (- 50) x3 ) (* (- 38) x3 ) (* 32 x1 ) (* (- 23) x1 ) (* 4 x4 ) (* 47 x2 ) ) 8) (not (= (+ (* (- 27) x3 ) (* 3 x1 ) (* (- 32) x2 ) ) (- 3))) )) +(assert (or (not (> (+ (* 17 x2 ) (* (- 43) x0 ) (* (- 39) x2 ) (* 38 x0 ) ) 43)) (not (<= (+ (* (- 16) x4 ) (* (- 21) x4 ) (* (- 42) x3 ) (* 36 x1 ) (* (- 37) x1 ) ) 41)) )) +(assert (or (> (+ (* 34 x3 ) (* 22 x1 ) ) 1) (not (<= (+ (* 1 x4 ) (* (- 45) x1 ) (* 28 x0 ) (* 34 x2 ) (* 26 x0 ) (* 3 x1 ) (* (- 33) x4 ) (* 18 x1 ) (* 33 x2 ) (* 15 x4 ) ) (- 25))) )) +(assert (or (> (+ (* (- 43) x2 ) (* (- 16) x4 ) (* 48 x0 ) (* (- 9) x0 ) (* (- 48) x0 ) (* (- 3) x1 ) (* (- 14) x4 ) (* (- 45) x1 ) (* (- 38) x1 ) (* 35 x2 ) ) (- 18)) (< (+ (* (- 5) x2 ) (* 0 x2 ) (* 13 x1 ) (* 28 x0 ) (* 29 x3 ) (* (- 45) x2 ) (* 0 x0 ) (* 35 x1 ) (* (- 33) x2 ) ) 35) (< (+ (* (- 3) x0 ) (* (- 27) x0 ) (* 8 x2 ) (* 2 x0 ) (* 4 x4 ) ) 48) )) +(check-sat) +(push 1) +(assert (= (+ (* (- 33) x3 ) (* 8 x2 ) (* (- 5) x4 ) (* (- 27) x1 ) (* 31 x4 ) (* (- 30) x2 ) (* 17 x2 ) (* (- 31) x3 ) (* 2 x2 ) ) 27) ) +(assert (not (= (+ (* 39 x2 ) (* 46 x3 ) (* (- 13) x1 ) (* 17 x0 ) (* 39 x1 ) (* (- 25) x0 ) ) 36)) ) +(assert (or (> (+ (* (- 2) x1 ) (* (- 9) x2 ) (* (- 20) x3 ) ) (- 4)) (> (+ (* (- 13) x4 ) (* (- 1) x2 ) (* 45 x2 ) (* 15 x2 ) (* (- 10) x4 ) (* 41 x2 ) (* (- 40) x1 ) ) 18) )) +(assert (or (not (<= (+ (* (- 8) x4 ) (* (- 21) x3 ) (* (- 44) x1 ) ) 9)) (= (+ (* (- 27) x2 ) (* 49 x2 ) (* (- 14) x4 ) (* (- 28) x1 ) ) (- 49)) (< (+ (* (- 7) x3 ) (* 44 x3 ) ) 13) )) +(assert (or (not (<= (+ (* (- 38) x2 ) (* 13 x1 ) (* (- 5) x0 ) (* 24 x2 ) (* (- 16) x4 ) (* (- 29) x0 ) ) 35)) (not (< (+ (* (- 39) x1 ) (* (- 40) x1 ) (* 37 x4 ) (* 47 x1 ) (* 19 x1 ) (* 46 x2 ) ) (- 44))) )) +(check-sat) +(pop 1) +(assert (<= (+ (* 47 x1 ) (* (- 49) x2 ) (* (- 33) x3 ) (* 18 x4 ) (* (- 18) x1 ) (* (- 10) x4 ) (* (- 38) x0 ) (* (- 6) x2 ) (* 10 x4 ) (* (- 18) x3 ) (* (- 25) x0 ) ) (- 21)) ) +(assert (or (not (<= (+ (* (- 29) x1 ) (* 12 x3 ) (* 15 x3 ) (* (- 49) x0 ) (* 40 x2 ) (* (- 25) x4 ) ) 24)) (not (>= (+ (* 18 x4 ) (* (- 14) x0 ) ) (- 22))) (<= (+ (* (- 1) x0 ) (* (- 31) x3 ) (* 21 x1 ) (* 12 x4 ) (* (- 28) x2 ) (* 12 x1 ) (* 42 x4 ) (* (- 29) x3 ) (* 34 x4 ) (* 10 x2 ) ) 6) )) +(assert (>= (+ (* 15 x1 ) (* (- 1) x4 ) (* (- 11) x0 ) (* (- 24) x1 ) (* 37 x3 ) ) (- 1)) ) +(assert (or (not (= (+ (* (- 1) x1 ) (* 22 x4 ) (* 5 x2 ) (* (- 29) x1 ) (* 15 x0 ) (* 46 x1 ) ) (- 40))) (< (+ (* (- 4) x0 ) (* 13 x2 ) ) 36) )) +(assert (or (<= (+ (* 33 x3 ) (* 43 x4 ) (* (- 9) x1 ) (* 32 x4 ) (* 18 x3 ) (* (- 29) x3 ) (* (- 45) x0 ) (* 26 x3 ) ) (- 48)) (>= (+ (* 36 x4 ) (* (- 18) x1 ) (* 27 x4 ) (* (- 8) x2 ) (* 12 x0 ) (* (- 41) x2 ) (* 19 x0 ) (* 8 x4 ) (* (- 2) x0 ) (* 25 x3 ) ) (- 34)) )) +(assert (or (>= (+ (* 40 x1 ) (* 35 x4 ) (* 29 x0 ) (* 28 x1 ) (* 22 x3 ) (* (- 8) x0 ) (* (- 18) x4 ) (* 48 x4 ) (* (- 48) x1 ) (* 45 x2 ) ) 10) (not (<= (+ (* 14 x1 ) (* (- 45) x3 ) (* 27 x2 ) (* (- 41) x1 ) (* (- 15) x4 ) (* 4 x1 ) (* (- 33) x1 ) (* 31 x2 ) (* (- 11) x1 ) (* 5 x4 ) (* (- 22) x2 ) ) (- 45))) (> (+ (* (- 7) x3 ) (* (- 42) x2 ) (* 9 x3 ) (* 39 x4 ) (* (- 3) x1 ) (* (- 38) x1 ) (* 35 x3 ) ) 49) )) +(assert (or (not (< (+ (* 14 x2 ) (* 21 x1 ) (* (- 10) x1 ) (* 26 x2 ) (* (- 16) x0 ) (* 20 x1 ) (* (- 46) x4 ) (* (- 20) x4 ) ) (- 35))) (not (> (+ (* 35 x2 ) (* (- 40) x2 ) (* (- 4) x2 ) (* (- 36) x1 ) (* (- 11) x2 ) ) 41)) )) +(check-sat) +(pop 1) +(assert (or (not (= (+ (* (- 42) x2 ) (* (- 42) x4 ) (* 5 x4 ) (* (- 40) x4 ) (* (- 19) x0 ) (* (- 46) x3 ) (* 18 x4 ) (* 11 x1 ) (* (- 34) x3 ) (* (- 3) x0 ) ) (- 20))) (> (+ (* 44 x1 ) (* 22 x4 ) (* (- 15) x4 ) (* 33 x1 ) (* (- 13) x4 ) (* 25 x2 ) ) 43) (not (> (+ (* 48 x2 ) (* (- 44) x0 ) (* 26 x3 ) (* (- 1) x0 ) (* (- 18) x2 ) (* 25 x1 ) (* (- 16) x1 ) (* 43 x0 ) (* 35 x0 ) (* 7 x2 ) ) 22)) )) +(assert (or (>= (+ (* (- 39) x3 ) (* (- 22) x0 ) (* (- 13) x4 ) (* (- 26) x4 ) (* 47 x0 ) (* (- 35) x3 ) (* 47 x1 ) (* 44 x2 ) (* 6 x2 ) (* (- 25) x4 ) ) (- 49)) (> (+ (* (- 16) x3 ) (* 9 x3 ) (* (- 34) x3 ) ) 45) )) +(assert (or (not (>= (+ (* (- 44) x2 ) (* 23 x3 ) ) (- 47))) (= (+ (* (- 10) x1 ) (* (- 30) x1 ) (* 27 x1 ) (* 47 x0 ) (* (- 43) x1 ) (* (- 41) x2 ) (* 15 x2 ) (* 47 x0 ) (* (- 34) x4 ) (* 11 x3 ) ) (- 42)) )) +(assert (or (< (+ (* (- 18) x1 ) (* 1 x4 ) (* 20 x1 ) (* (- 16) x3 ) (* (- 11) x3 ) (* 38 x2 ) (* (- 47) x3 ) (* 5 x3 ) ) 14) (not (= (+ (* (- 43) x2 ) (* 32 x0 ) ) (- 30))) (not (> (+ (* (- 17) x4 ) (* (- 40) x4 ) (* (- 45) x2 ) (* (- 47) x4 ) (* 7 x3 ) ) 40)) )) +(assert (not (= (+ (* 9 x2 ) (* 23 x0 ) (* (- 32) x4 ) (* 38 x0 ) ) 27)) ) +(check-sat) +(push 1) +(assert (or (= (+ (* 11 x0 ) (* (- 7) x3 ) (* 39 x4 ) ) 7) (not (< (+ (* 38 x4 ) (* 28 x0 ) (* (- 45) x4 ) (* 9 x2 ) (* 11 x0 ) (* (- 30) x0 ) ) (- 27))) (not (< (+ (* 48 x4 ) (* 2 x2 ) (* (- 46) x3 ) ) (- 37))) )) +(assert (not (< (+ (* (- 6) x4 ) (* (- 47) x0 ) (* 40 x4 ) (* (- 14) x4 ) (* (- 29) x0 ) (* 47 x2 ) ) (- 16))) ) +(check-sat) +(pop 1) +(assert (not (>= (+ (* 23 x2 ) (* (- 30) x1 ) (* (- 48) x4 ) (* 27 x1 ) (* (- 16) x1 ) (* 27 x0 ) (* 10 x3 ) (* 13 x3 ) ) (- 47))) ) +(assert (or (< (+ (* 25 x3 ) (* 15 x0 ) ) (- 17)) (< (+ (* 3 x0 ) (* (- 11) x1 ) (* (- 10) x3 ) (* (- 19) x3 ) (* (- 11) x4 ) (* 5 x0 ) (* 46 x2 ) (* (- 48) x2 ) ) (- 39)) )) +(assert (or (not (>= (+ (* 19 x3 ) (* 15 x4 ) (* 19 x1 ) (* (- 28) x3 ) ) 5)) (not (< (+ (* 2 x0 ) (* (- 32) x4 ) (* (- 22) x4 ) (* (- 49) x4 ) (* 28 x3 ) (* (- 47) x4 ) ) 30)) )) +(assert (or (< (+ (* 32 x4 ) (* 45 x2 ) (* (- 44) x3 ) (* (- 19) x0 ) (* (- 30) x0 ) (* (- 42) x2 ) (* 44 x4 ) (* 48 x0 ) (* 46 x2 ) (* 24 x1 ) (* 12 x0 ) ) 2) (not (> (+ (* (- 8) x0 ) (* (- 16) x4 ) (* (- 5) x1 ) (* (- 42) x2 ) (* (- 33) x1 ) (* (- 44) x1 ) (* 49 x0 ) (* (- 32) x3 ) (* (- 33) x4 ) (* (- 31) x4 ) (* 27 x2 ) ) 18)) (not (> (+ (* 5 x0 ) (* 27 x2 ) (* (- 21) x0 ) (* 25 x4 ) (* 10 x1 ) (* (- 17) x2 ) (* (- 37) x1 ) (* (- 11) x2 ) ) 21)) )) +(check-sat) +(push 1) +(assert (not (>= (+ (* 19 x2 ) (* 16 x2 ) (* (- 17) x4 ) (* (- 43) x4 ) ) 43)) ) +(assert (not (> (+ (* (- 6) x1 ) (* 4 x4 ) (* 9 x1 ) (* 32 x0 ) ) 11)) ) +(assert (or (not (> (+ (* 4 x1 ) (* (- 25) x3 ) (* 12 x0 ) (* 14 x1 ) (* 10 x2 ) ) (- 27))) (<= (+ (* 3 x4 ) (* (- 43) x0 ) (* 34 x4 ) (* 16 x1 ) ) (- 7)) )) +(assert (not (> (+ (* (- 38) x1 ) (* (- 43) x2 ) (* (- 18) x3 ) (* (- 4) x2 ) (* 25 x1 ) (* 43 x0 ) (* (- 16) x0 ) (* 22 x2 ) ) 36)) ) +(assert (= (+ (* 22 x2 ) (* (- 23) x0 ) (* 47 x2 ) (* (- 31) x3 ) (* 4 x0 ) (* 9 x3 ) (* (- 48) x4 ) (* 48 x1 ) ) (- 2)) ) +(assert (or (>= (+ (* (- 31) x1 ) (* (- 16) x3 ) ) (- 28)) (<= (+ (* (- 36) x2 ) (* (- 11) x4 ) (* (- 29) x1 ) (* 26 x1 ) (* 36 x1 ) ) (- 19)) (<= (+ (* 39 x3 ) (* 28 x0 ) (* 19 x4 ) (* (- 37) x1 ) (* 39 x1 ) (* 14 x3 ) (* (- 43) x4 ) (* 8 x4 ) ) 42) )) +(assert (< (+ (* 46 x0 ) (* 18 x3 ) (* (- 24) x3 ) (* 31 x4 ) (* 25 x3 ) ) 20) ) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_5_3.smt2 b/test/regress/regress1/push-pop/fuzz_5_3.smt2 new file mode 100644 index 000000000..b61eb001f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_5_3.smt2 @@ -0,0 +1,66 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(assert (or (<= (+ (* 30 x0 ) (* 33 x1 ) (* 40 x1 ) (* 27 x3 ) (* 17 x3 ) (* (- 18) x0 ) (* (- 30) x0 ) ) (- 46)) (> (+ (* 48 x3 ) (* 16 x1 ) (* (- 20) x4 ) (* (- 22) x1 ) (* (- 11) x3 ) (* (- 27) x0 ) (* 8 x2 ) (* (- 17) x1 ) (* (- 21) x1 ) (* 19 x0 ) ) 8) (not (> (+ (* 24 x4 ) (* (- 7) x0 ) (* 11 x4 ) (* (- 17) x1 ) (* 3 x1 ) (* 36 x1 ) (* (- 16) x0 ) ) 16)) )) +(assert (or (> (+ (* (- 30) x1 ) (* (- 6) x3 ) (* 33 x4 ) (* 9 x4 ) (* (- 47) x0 ) ) 30) (not (<= (+ (* 44 x3 ) (* (- 34) x1 ) (* (- 5) x2 ) (* (- 20) x1 ) (* 6 x1 ) (* (- 1) x4 ) (* 40 x2 ) (* 11 x4 ) (* 48 x3 ) (* 23 x3 ) (* (- 16) x2 ) ) 6)) )) +(assert (or (not (> (+ (* (- 9) x3 ) (* (- 49) x4 ) (* (- 23) x2 ) (* (- 36) x2 ) (* (- 11) x2 ) (* 5 x1 ) (* 10 x2 ) (* (- 6) x1 ) (* 1 x1 ) (* (- 34) x0 ) ) (- 1))) (> (+ (* 48 x4 ) (* 20 x0 ) ) 47) (not (<= (+ (* 39 x1 ) (* (- 7) x3 ) (* (- 3) x4 ) (* 43 x4 ) (* (- 45) x1 ) ) (- 49))) )) +(assert (>= (+ (* 38 x0 ) (* 11 x0 ) (* (- 23) x3 ) (* 5 x0 ) (* 7 x1 ) (* 25 x0 ) (* (- 30) x0 ) (* (- 21) x2 ) (* (- 20) x0 ) ) (- 26)) ) +(assert (or (> (+ (* (- 25) x1 ) (* (- 41) x4 ) (* 34 x3 ) (* 45 x3 ) (* (- 34) x2 ) (* (- 47) x2 ) ) (- 7)) (< (+ (* 33 x1 ) (* (- 7) x1 ) (* (- 50) x3 ) (* 15 x2 ) ) 32) (= (+ (* 23 x3 ) (* 24 x0 ) (* (- 16) x3 ) (* (- 17) x4 ) (* 12 x0 ) (* (- 7) x4 ) (* (- 12) x0 ) (* 24 x3 ) (* 6 x2 ) ) (- 3)) )) +(assert (< (+ (* (- 11) x1 ) (* 29 x2 ) (* 10 x3 ) (* 21 x3 ) (* (- 27) x3 ) (* (- 18) x2 ) (* 31 x4 ) (* 29 x2 ) ) 46) ) +(assert (= (+ (* 38 x2 ) (* 2 x0 ) (* 21 x1 ) (* (- 20) x3 ) (* 46 x3 ) (* (- 20) x1 ) (* (- 41) x2 ) (* 20 x2 ) ) (- 18)) ) +(assert (or (= (+ (* 27 x3 ) (* 9 x4 ) (* (- 42) x4 ) (* (- 38) x2 ) (* (- 8) x3 ) (* (- 37) x1 ) (* 14 x4 ) (* 44 x0 ) (* 5 x4 ) (* (- 35) x0 ) (* (- 32) x2 ) ) 26) (> (+ (* (- 16) x0 ) (* (- 35) x0 ) (* 3 x3 ) (* (- 28) x3 ) (* 19 x4 ) (* (- 49) x3 ) (* (- 34) x1 ) (* (- 16) x0 ) (* 39 x4 ) (* 16 x4 ) (* 43 x3 ) ) (- 29)) (not (<= (+ (* (- 13) x4 ) (* 34 x0 ) (* (- 5) x1 ) (* 38 x3 ) (* 9 x3 ) (* 8 x1 ) (* (- 45) x1 ) (* (- 34) x4 ) ) 8)) )) +(check-sat) +(push 1) +(assert (or (<= (+ (* (- 18) x3 ) (* 41 x1 ) (* 7 x1 ) (* (- 34) x2 ) (* (- 8) x3 ) (* (- 13) x3 ) (* 6 x0 ) (* (- 22) x1 ) (* 17 x4 ) ) 19) (< (+ (* (- 33) x3 ) (* 20 x1 ) (* (- 8) x1 ) (* 17 x4 ) (* 17 x0 ) (* 23 x2 ) (* (- 40) x1 ) (* (- 35) x2 ) (* (- 15) x3 ) (* (- 13) x2 ) (* 47 x2 ) ) 43) )) +(assert (or (not (< (+ (* (- 2) x3 ) (* 1 x2 ) (* 11 x0 ) (* (- 32) x3 ) (* (- 7) x3 ) (* (- 5) x3 ) ) (- 40))) (< (+ (* (- 50) x2 ) (* (- 20) x2 ) ) 37) )) +(assert (or (= (+ (* 19 x2 ) (* (- 10) x1 ) ) (- 34)) (<= (+ (* 7 x0 ) (* 46 x1 ) (* 7 x0 ) (* (- 37) x4 ) (* (- 1) x2 ) (* 23 x0 ) (* 9 x3 ) (* 10 x0 ) (* (- 37) x0 ) (* (- 41) x1 ) (* 0 x0 ) ) 24) )) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (= (+ (* (- 20) x1 ) (* 32 x3 ) (* (- 21) x2 ) (* (- 9) x2 ) (* 5 x1 ) (* 4 x4 ) (* 42 x4 ) (* 6 x4 ) (* 22 x2 ) (* 32 x3 ) (* 42 x3 ) ) 1) ) +(assert (or (not (>= (+ (* (- 39) x0 ) (* 19 x4 ) (* (- 1) x3 ) ) (- 47))) (not (<= (+ (* (- 40) x4 ) (* (- 10) x2 ) (* 22 x4 ) (* (- 20) x4 ) ) 30)) )) +(assert (not (= (+ (* (- 23) x0 ) (* 33 x4 ) (* (- 43) x0 ) (* (- 48) x4 ) (* 8 x1 ) (* (- 34) x1 ) (* 24 x3 ) (* 37 x4 ) (* (- 27) x2 ) (* (- 16) x4 ) ) (- 35))) ) +(assert (not (>= (+ (* (- 1) x3 ) (* 19 x4 ) ) 29)) ) +(assert (or (not (> (+ (* (- 36) x3 ) (* (- 16) x0 ) (* 12 x3 ) (* (- 17) x2 ) (* 1 x3 ) ) 22)) (< (+ (* (- 8) x2 ) (* (- 40) x1 ) (* (- 17) x4 ) (* 37 x1 ) (* 41 x2 ) (* (- 37) x1 ) (* (- 46) x3 ) ) (- 33)) )) +(assert (<= (+ (* 27 x1 ) (* 18 x4 ) ) 12) ) +(assert (or (not (> (+ (* (- 43) x0 ) (* 43 x0 ) (* 36 x2 ) (* 21 x1 ) (* 11 x1 ) (* 32 x4 ) ) 24)) (not (< (+ (* 33 x0 ) (* 29 x3 ) (* 39 x3 ) (* 17 x4 ) (* 21 x0 ) (* 32 x2 ) (* (- 38) x1 ) (* (- 37) x0 ) (* 23 x4 ) ) (- 43))) (not (<= (+ (* 35 x4 ) (* 23 x1 ) (* 23 x0 ) (* (- 39) x0 ) (* (- 13) x4 ) (* (- 10) x1 ) (* (- 33) x2 ) (* 28 x1 ) (* 41 x4 ) (* 43 x4 ) ) 23)) )) +(check-sat) +(pop 1) +(assert (or (not (= (+ (* (- 12) x0 ) (* (- 26) x2 ) (* (- 34) x1 ) (* 46 x0 ) (* (- 38) x4 ) (* (- 45) x4 ) ) 0)) (not (>= (+ (* (- 23) x2 ) (* 9 x2 ) (* 48 x0 ) (* (- 6) x2 ) (* (- 40) x1 ) (* (- 19) x0 ) (* (- 21) x4 ) ) 13)) (not (<= (+ (* 45 x1 ) (* 28 x3 ) (* (- 13) x1 ) ) 40)) )) +(check-sat) +(push 1) +(assert (or (>= (+ (* (- 31) x0 ) (* 39 x3 ) (* (- 43) x2 ) (* (- 12) x4 ) (* (- 46) x0 ) (* 46 x3 ) (* 19 x0 ) (* (- 8) x4 ) (* 41 x3 ) (* 34 x0 ) ) (- 10)) (not (>= (+ (* (- 20) x3 ) (* (- 19) x4 ) (* (- 33) x3 ) (* 18 x2 ) (* (- 47) x1 ) (* 28 x0 ) (* 6 x0 ) (* (- 23) x1 ) (* 6 x0 ) (* 0 x0 ) ) (- 25))) )) +(assert (or (not (>= (+ (* 19 x0 ) (* 27 x4 ) (* (- 45) x4 ) (* (- 27) x2 ) (* (- 5) x3 ) (* (- 20) x0 ) ) 16)) (not (> (+ (* 45 x4 ) (* (- 22) x4 ) (* 46 x4 ) (* (- 1) x1 ) (* 12 x3 ) (* (- 7) x0 ) (* 15 x3 ) (* 28 x4 ) (* 26 x4 ) (* 35 x2 ) (* (- 35) x1 ) ) 11)) )) +(assert (or (not (<= (+ (* 35 x2 ) (* 44 x3 ) (* 44 x2 ) ) (- 28))) (> (+ (* 39 x3 ) (* (- 6) x2 ) (* 2 x4 ) (* (- 5) x4 ) (* 45 x2 ) (* 40 x1 ) (* 4 x1 ) (* (- 8) x0 ) (* (- 33) x3 ) ) 45) )) +(assert (or (> (+ (* 46 x4 ) (* (- 4) x0 ) ) 5) (>= (+ (* (- 21) x1 ) (* 22 x0 ) (* 19 x3 ) (* (- 34) x3 ) (* 41 x1 ) (* (- 1) x1 ) (* (- 39) x1 ) ) 41) )) +(assert (<= (+ (* (- 38) x4 ) (* 43 x1 ) (* 46 x4 ) (* 14 x1 ) (* 49 x3 ) (* (- 18) x3 ) (* 38 x0 ) (* (- 36) x4 ) (* 24 x4 ) (* 28 x0 ) (* (- 14) x3 ) ) (- 23)) ) +(assert (not (< (+ (* 36 x0 ) (* (- 19) x4 ) (* 5 x3 ) ) 26)) ) +(assert (or (> (+ (* (- 46) x3 ) (* 1 x0 ) (* 37 x0 ) (* (- 44) x0 ) (* 45 x3 ) (* (- 19) x1 ) (* 14 x3 ) (* (- 16) x2 ) (* 35 x2 ) (* 47 x0 ) (* (- 21) x3 ) ) 30) (< (+ (* (- 11) x3 ) (* 7 x2 ) (* (- 5) x3 ) ) (- 37)) )) +(assert (not (> (+ (* 23 x4 ) (* (- 45) x0 ) ) 6)) ) +(assert (or (not (> (+ (* 45 x4 ) (* (- 38) x2 ) (* (- 13) x4 ) (* 11 x0 ) (* (- 32) x0 ) (* 22 x2 ) ) (- 23))) (> (+ (* (- 32) x0 ) (* 24 x3 ) (* (- 26) x4 ) (* (- 6) x2 ) ) (- 20)) )) +(check-sat) +(push 1) +(assert (or (>= (+ (* 19 x4 ) (* 39 x3 ) (* 0 x2 ) (* (- 46) x2 ) (* (- 44) x4 ) (* (- 2) x4 ) (* 1 x4 ) (* 14 x1 ) (* 47 x4 ) (* 3 x3 ) (* (- 12) x1 ) ) 0) (<= (+ (* 4 x0 ) (* 17 x4 ) (* (- 26) x0 ) (* (- 30) x1 ) (* 45 x0 ) ) 20) )) +(assert (or (not (< (+ (* 24 x2 ) (* (- 17) x2 ) (* 3 x0 ) ) 32)) (not (< (+ (* (- 41) x4 ) (* 15 x4 ) (* 16 x4 ) ) (- 31))) (not (< (+ (* 24 x4 ) (* 1 x1 ) ) 19)) )) +(assert (or (< (+ (* 2 x1 ) (* (- 12) x0 ) (* (- 37) x2 ) (* 22 x4 ) (* (- 47) x4 ) ) (- 22)) (>= (+ (* 13 x0 ) (* (- 49) x1 ) (* 41 x3 ) (* 10 x4 ) (* (- 25) x0 ) (* 37 x1 ) (* 32 x3 ) ) 10) (= (+ (* (- 50) x4 ) (* 49 x2 ) (* (- 49) x3 ) (* 9 x1 ) (* 1 x1 ) (* (- 30) x4 ) (* (- 44) x0 ) ) 33) )) +(assert (or (< (+ (* (- 45) x1 ) (* 34 x3 ) (* (- 41) x4 ) (* 7 x3 ) (* (- 2) x1 ) (* 26 x4 ) (* (- 17) x1 ) (* (- 36) x2 ) (* 48 x2 ) (* (- 7) x1 ) (* 0 x4 ) ) (- 34)) (not (< (+ (* (- 34) x3 ) (* (- 22) x0 ) (* (- 17) x0 ) ) 35)) )) +(assert (or (not (> (+ (* 48 x2 ) (* 13 x2 ) ) (- 24))) (> (+ (* (- 15) x4 ) (* 32 x3 ) ) (- 19)) (not (= (+ (* (- 8) x0 ) (* (- 15) x3 ) (* (- 39) x3 ) (* 15 x0 ) (* (- 49) x1 ) (* 16 x1 ) ) 33)) )) +(assert (not (>= (+ (* 41 x2 ) (* 35 x4 ) (* 40 x4 ) (* 49 x3 ) ) 23)) ) +(assert (or (not (>= (+ (* (- 45) x0 ) (* (- 40) x4 ) (* 0 x1 ) (* 15 x1 ) (* (- 38) x3 ) (* 36 x1 ) (* (- 12) x1 ) (* 47 x0 ) (* 47 x2 ) (* (- 34) x3 ) ) (- 16))) (not (>= (+ (* (- 18) x4 ) (* (- 10) x0 ) (* 20 x2 ) (* (- 8) x4 ) (* (- 25) x1 ) (* (- 6) x2 ) (* 30 x2 ) ) (- 41))) (> (+ (* 26 x3 ) (* (- 22) x1 ) ) 23) )) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_5_4.smt2 b/test/regress/regress1/push-pop/fuzz_5_4.smt2 new file mode 100644 index 000000000..5d46d281f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_5_4.smt2 @@ -0,0 +1,54 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(check-sat) +(push 1) +(assert (or (not (< (+ (* 22 x2 ) (* (- 45) x4 ) (* (- 27) x4 ) (* (- 23) x1 ) (* (- 38) x4 ) (* 12 x0 ) (* 11 x2 ) (* 6 x4 ) (* (- 34) x3 ) (* (- 28) x3 ) ) (- 7))) (> (+ (* 49 x3 ) (* (- 9) x3 ) (* (- 6) x2 ) (* (- 39) x2 ) (* 49 x3 ) (* (- 6) x4 ) (* 35 x4 ) (* (- 5) x1 ) ) 47) (not (= (+ (* (- 37) x0 ) (* 23 x0 ) (* 8 x0 ) (* (- 25) x3 ) (* (- 10) x4 ) (* (- 31) x3 ) (* (- 7) x1 ) (* (- 9) x2 ) (* 42 x4 ) (* 9 x2 ) (* (- 29) x1 ) ) (- 47))) )) +(assert (or (> (+ (* 20 x0 ) (* 28 x0 ) (* 40 x0 ) (* (- 33) x1 ) (* 1 x3 ) (* 24 x2 ) (* (- 40) x1 ) (* 33 x1 ) ) (- 45)) (>= (+ (* 26 x0 ) (* 43 x3 ) (* 8 x3 ) (* (- 41) x0 ) (* 23 x0 ) (* (- 18) x2 ) (* 13 x0 ) (* 32 x0 ) (* (- 36) x0 ) (* (- 44) x0 ) ) 15) )) +(assert (or (not (> (+ (* (- 40) x0 ) (* (- 34) x4 ) (* 41 x2 ) (* (- 40) x4 ) (* 44 x2 ) (* (- 3) x1 ) (* (- 44) x3 ) (* (- 29) x2 ) (* (- 31) x3 ) ) (- 14))) (< (+ (* (- 48) x0 ) (* 30 x4 ) (* (- 18) x4 ) ) 39) (>= (+ (* 1 x2 ) (* (- 31) x2 ) (* (- 8) x0 ) ) 31) )) +(assert (or (not (= (+ (* (- 46) x0 ) (* 1 x3 ) (* (- 1) x3 ) (* 27 x2 ) ) (- 8))) (not (= (+ (* 26 x4 ) (* 39 x4 ) (* (- 14) x4 ) (* (- 9) x0 ) (* 18 x0 ) (* (- 15) x2 ) (* (- 4) x2 ) (* 0 x2 ) (* 48 x3 ) ) (- 8))) (<= (+ (* (- 20) x2 ) (* (- 34) x1 ) (* 49 x4 ) ) 33) )) +(assert (or (not (>= (+ (* (- 2) x3 ) (* (- 4) x0 ) (* (- 3) x0 ) (* 4 x1 ) (* 30 x4 ) (* (- 49) x0 ) ) (- 20))) (> (+ (* 8 x0 ) (* 24 x0 ) (* 39 x3 ) (* (- 2) x0 ) (* (- 25) x0 ) (* (- 17) x1 ) (* (- 40) x1 ) (* (- 15) x2 ) (* 9 x3 ) (* (- 2) x3 ) (* 49 x4 ) ) (- 47)) (not (<= (+ (* 11 x0 ) (* 49 x4 ) (* 16 x4 ) (* 17 x4 ) (* 0 x2 ) ) 6)) )) +(assert (or (not (< (+ (* 21 x1 ) (* 35 x1 ) (* (- 41) x3 ) (* 41 x1 ) (* 5 x3 ) (* (- 37) x2 ) (* 23 x4 ) (* (- 6) x3 ) (* (- 25) x4 ) (* (- 29) x0 ) ) (- 7))) (< (+ (* (- 2) x4 ) (* (- 46) x0 ) (* (- 20) x1 ) (* 27 x0 ) (* (- 2) x3 ) (* (- 39) x4 ) ) 8) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* (- 49) x1 ) (* 5 x1 ) (* 8 x3 ) (* (- 28) x1 ) (* 18 x2 ) (* 19 x0 ) (* (- 18) x1 ) (* (- 38) x0 ) ) 12)) (not (= (+ (* 5 x1 ) (* (- 21) x3 ) (* 34 x3 ) (* 34 x4 ) (* 32 x2 ) ) 49)) (= (+ (* (- 36) x1 ) (* 39 x0 ) (* (- 16) x3 ) (* 0 x3 ) (* 24 x3 ) ) 33) )) +(assert (or (<= (+ (* (- 23) x0 ) (* 45 x1 ) (* 4 x4 ) (* 8 x0 ) (* 14 x0 ) (* (- 9) x1 ) (* 27 x3 ) (* 29 x3 ) (* (- 27) x3 ) ) 18) (not (< (+ (* (- 37) x4 ) (* (- 33) x3 ) (* 42 x1 ) (* (- 48) x0 ) (* 30 x2 ) (* 10 x4 ) ) (- 23))) (= (+ (* 6 x4 ) (* (- 8) x2 ) ) 47) )) +(assert (not (< (+ (* 43 x2 ) (* (- 13) x0 ) (* 35 x2 ) (* (- 25) x2 ) ) (- 48))) ) +(assert (or (>= (+ (* (- 19) x4 ) (* 27 x0 ) (* (- 34) x2 ) (* (- 27) x1 ) (* 10 x0 ) (* 24 x2 ) (* (- 10) x4 ) (* (- 23) x2 ) (* (- 44) x1 ) (* 7 x1 ) (* 43 x3 ) ) 44) (> (+ (* 37 x0 ) (* (- 3) x3 ) (* (- 31) x3 ) (* 28 x4 ) (* 3 x1 ) (* 35 x2 ) (* (- 26) x3 ) (* (- 5) x2 ) (* 2 x3 ) ) 35) )) +(assert (= (+ (* (- 23) x0 ) (* 44 x0 ) (* (- 35) x0 ) ) 45) ) +(assert (or (< (+ (* 3 x2 ) (* 31 x1 ) (* 10 x1 ) (* (- 16) x1 ) (* 13 x4 ) ) (- 19)) (not (< (+ (* (- 3) x2 ) (* 46 x4 ) (* 10 x4 ) (* 47 x1 ) (* 3 x1 ) (* (- 49) x2 ) (* (- 35) x2 ) ) 16)) (>= (+ (* (- 39) x2 ) (* (- 42) x0 ) (* 48 x2 ) (* (- 42) x4 ) (* (- 25) x3 ) (* 31 x3 ) (* 6 x3 ) (* 3 x0 ) (* 29 x4 ) (* 30 x0 ) (* (- 27) x1 ) ) 35) )) +(assert (or (> (+ (* (- 44) x2 ) (* (- 33) x2 ) (* 24 x4 ) (* (- 9) x2 ) (* 22 x4 ) ) 0) (not (<= (+ (* (- 7) x1 ) (* 1 x1 ) (* 8 x3 ) (* (- 37) x2 ) (* (- 39) x3 ) (* 26 x1 ) (* (- 37) x2 ) (* (- 38) x4 ) (* (- 47) x2 ) (* 1 x0 ) ) (- 30))) )) +(assert (or (not (= (+ (* 33 x2 ) (* (- 27) x2 ) (* 13 x0 ) (* (- 16) x3 ) (* 16 x1 ) (* (- 1) x2 ) (* (- 20) x1 ) (* (- 30) x2 ) (* 14 x3 ) (* (- 3) x0 ) ) (- 22))) (not (> (+ (* (- 27) x1 ) (* (- 26) x2 ) (* 20 x3 ) (* (- 3) x3 ) (* 21 x0 ) (* 36 x1 ) ) (- 16))) (< (+ (* (- 38) x0 ) (* 41 x2 ) (* (- 36) x4 ) ) 13) )) +(assert (or (> (+ (* 5 x3 ) (* (- 9) x3 ) (* (- 5) x1 ) (* 6 x2 ) (* 46 x3 ) (* (- 25) x1 ) (* 29 x2 ) (* 3 x3 ) (* (- 15) x0 ) (* 30 x1 ) (* 10 x4 ) ) (- 26)) (= (+ (* 6 x4 ) (* (- 47) x3 ) (* (- 18) x1 ) (* 24 x1 ) (* 44 x0 ) (* (- 7) x2 ) ) (- 48)) )) +(assert (or (not (> (+ (* 31 x2 ) (* 8 x1 ) (* (- 32) x1 ) (* (- 34) x3 ) (* (- 36) x3 ) (* (- 45) x2 ) (* (- 37) x2 ) (* 40 x3 ) (* 30 x3 ) (* 29 x4 ) ) (- 44))) (not (<= (+ (* (- 22) x0 ) (* (- 16) x2 ) ) 36)) (>= (+ (* 5 x3 ) (* (- 9) x4 ) ) (- 25)) )) +(assert (or (not (> (+ (* 43 x3 ) (* (- 24) x3 ) (* 7 x3 ) (* (- 40) x3 ) (* (- 33) x3 ) (* (- 36) x2 ) (* 7 x2 ) (* 20 x2 ) ) (- 7))) (= (+ (* 37 x4 ) (* 40 x4 ) ) 30) )) +(assert (or (>= (+ (* 43 x0 ) (* 4 x4 ) ) 21) (not (= (+ (* 1 x4 ) (* (- 44) x4 ) (* 48 x0 ) (* 9 x0 ) ) 18)) )) +(check-sat) +(push 1) +(assert (or (not (>= (+ (* (- 48) x2 ) (* 4 x1 ) (* (- 2) x4 ) (* (- 41) x0 ) (* 9 x1 ) (* 14 x0 ) (* 28 x3 ) (* (- 12) x3 ) ) (- 20))) (= (+ (* (- 38) x1 ) (* (- 34) x4 ) (* 1 x4 ) (* (- 26) x4 ) (* (- 30) x2 ) (* 36 x3 ) (* (- 14) x2 ) (* (- 32) x2 ) (* 2 x4 ) ) (- 22)) )) +(assert (or (not (<= (+ (* 42 x4 ) (* (- 46) x0 ) (* 41 x4 ) (* (- 13) x3 ) (* (- 36) x0 ) ) (- 44))) (not (= (+ (* 15 x4 ) (* 24 x2 ) ) 1)) (< (+ (* (- 4) x0 ) (* 0 x3 ) (* 10 x3 ) (* 18 x1 ) ) (- 33)) )) +(assert (or (= (+ (* (- 19) x3 ) (* (- 39) x4 ) (* (- 5) x1 ) (* (- 39) x3 ) ) (- 48)) (= (+ (* 30 x3 ) (* (- 15) x1 ) (* 8 x1 ) (* (- 26) x1 ) (* 6 x4 ) (* 5 x1 ) (* 3 x4 ) (* (- 13) x2 ) (* (- 47) x2 ) (* 23 x4 ) (* 28 x4 ) ) 34) (= (+ (* (- 20) x4 ) (* (- 30) x3 ) ) (- 36)) )) +(check-sat) +(push 1) +(assert (or (not (>= (+ (* 20 x0 ) (* 43 x2 ) (* (- 49) x2 ) (* (- 46) x2 ) (* 14 x3 ) (* 27 x4 ) (* 43 x2 ) (* 23 x3 ) (* (- 14) x1 ) (* 20 x2 ) ) 16)) (< (+ (* 45 x1 ) (* (- 31) x3 ) ) 25) (<= (+ (* 15 x4 ) (* 41 x4 ) (* 23 x4 ) (* (- 41) x2 ) ) 39) )) +(check-sat) +(pop 1) +(assert (or (> (+ (* (- 43) x0 ) (* (- 49) x0 ) (* (- 8) x2 ) (* (- 29) x4 ) (* (- 32) x2 ) (* (- 37) x0 ) (* 31 x2 ) (* 27 x0 ) (* 21 x3 ) ) (- 30)) (> (+ (* (- 16) x4 ) (* 20 x1 ) (* 28 x3 ) (* 15 x4 ) (* (- 46) x3 ) (* 10 x2 ) (* 12 x2 ) (* 42 x3 ) (* 42 x3 ) (* 25 x0 ) (* (- 26) x2 ) ) (- 42)) (not (>= (+ (* 24 x4 ) (* 21 x3 ) (* 9 x4 ) (* (- 30) x0 ) (* (- 32) x4 ) ) 1)) )) +(assert (or (<= (+ (* 10 x2 ) (* (- 23) x4 ) (* (- 41) x4 ) ) (- 31)) (>= (+ (* (- 5) x0 ) (* (- 6) x2 ) (* 8 x4 ) (* 34 x3 ) (* 14 x4 ) (* 36 x4 ) (* 23 x1 ) (* (- 11) x1 ) ) (- 26)) (not (< (+ (* 25 x1 ) (* (- 20) x3 ) (* (- 8) x2 ) (* 23 x4 ) (* 25 x3 ) (* 1 x2 ) ) 22)) )) +(assert (or (not (<= (+ (* 28 x3 ) (* (- 41) x4 ) (* (- 33) x0 ) (* (- 29) x4 ) (* 8 x2 ) (* (- 42) x2 ) (* 23 x2 ) (* 25 x0 ) (* (- 13) x3 ) (* 44 x0 ) ) (- 40))) (<= (+ (* (- 8) x1 ) (* (- 22) x1 ) ) (- 27)) (not (< (+ (* 24 x2 ) (* (- 6) x0 ) (* 29 x2 ) (* (- 1) x2 ) (* (- 15) x0 ) (* (- 23) x4 ) (* 46 x3 ) (* 14 x4 ) (* 26 x3 ) (* 45 x3 ) ) (- 43))) )) +(assert (or (not (>= (+ (* 48 x2 ) (* 12 x4 ) (* 41 x4 ) (* (- 19) x2 ) (* 31 x2 ) (* (- 45) x2 ) (* 2 x2 ) (* (- 7) x0 ) (* (- 50) x4 ) (* (- 16) x4 ) ) 14)) (> (+ (* 19 x4 ) (* (- 18) x0 ) (* (- 20) x0 ) (* 29 x3 ) ) (- 22)) )) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_5_5.smt2 b/test/regress/regress1/push-pop/fuzz_5_5.smt2 new file mode 100644 index 000000000..72b2aa088 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_5_5.smt2 @@ -0,0 +1,78 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(assert (or (not (= (+ (* 23 x2 ) (* (- 43) x4 ) (* (- 39) x3 ) (* 4 x2 ) ) (- 2))) (>= (+ (* (- 1) x2 ) (* 0 x0 ) (* 31 x1 ) (* 20 x1 ) (* (- 27) x2 ) ) 22) (<= (+ (* 42 x1 ) (* (- 4) x4 ) (* 12 x2 ) (* 36 x1 ) (* (- 36) x4 ) (* 18 x4 ) (* 47 x0 ) ) (- 19)) )) +(assert (or (>= (+ (* 4 x1 ) (* (- 32) x2 ) (* 47 x1 ) ) 43) (< (+ (* 31 x4 ) (* 33 x0 ) (* 27 x2 ) (* 0 x0 ) (* (- 35) x0 ) (* 14 x4 ) (* 35 x0 ) (* 17 x4 ) (* 7 x3 ) (* (- 19) x3 ) ) (- 42)) )) +(assert (not (>= (+ (* (- 36) x0 ) (* (- 28) x2 ) (* (- 49) x2 ) (* (- 17) x0 ) (* (- 16) x2 ) ) (- 40))) ) +(assert (or (not (>= (+ (* 35 x4 ) (* (- 42) x1 ) (* (- 31) x4 ) (* (- 36) x3 ) (* 28 x3 ) (* (- 10) x0 ) (* 37 x1 ) (* 11 x1 ) (* (- 29) x3 ) (* 31 x1 ) ) (- 28))) (>= (+ (* 26 x1 ) (* 12 x4 ) (* (- 7) x1 ) ) (- 39)) )) +(check-sat) +(push 1) +(assert (or (< (+ (* 48 x4 ) (* 8 x4 ) (* (- 34) x4 ) (* (- 47) x4 ) (* (- 7) x3 ) (* 46 x1 ) (* (- 13) x1 ) (* (- 28) x3 ) (* (- 20) x3 ) (* 30 x0 ) (* (- 35) x1 ) ) 36) (>= (+ (* (- 22) x0 ) (* (- 14) x4 ) (* (- 22) x4 ) (* (- 25) x2 ) (* 1 x3 ) (* 18 x1 ) (* (- 34) x4 ) (* 12 x1 ) (* (- 8) x2 ) (* 33 x0 ) (* (- 47) x1 ) ) 15) )) +(assert (>= (+ (* 12 x2 ) (* 14 x3 ) (* (- 36) x2 ) ) (- 49)) ) +(assert (or (> (+ (* (- 40) x1 ) (* 47 x1 ) (* 14 x1 ) (* 41 x4 ) (* (- 39) x3 ) (* (- 23) x4 ) (* 41 x2 ) (* (- 48) x1 ) (* (- 18) x2 ) (* 46 x1 ) ) (- 4)) (not (< (+ (* (- 36) x3 ) (* (- 47) x4 ) (* 3 x4 ) (* (- 5) x4 ) ) 13)) (< (+ (* (- 45) x2 ) (* (- 33) x2 ) (* 8 x2 ) (* 34 x4 ) ) (- 1)) )) +(assert (or (<= (+ (* 25 x0 ) (* 41 x4 ) (* (- 33) x1 ) (* (- 50) x2 ) (* (- 39) x3 ) ) 3) (> (+ (* (- 48) x4 ) (* 13 x0 ) (* 44 x2 ) (* (- 26) x3 ) ) 3) (= (+ (* (- 3) x2 ) (* 48 x1 ) (* 16 x4 ) (* (- 27) x0 ) (* 43 x4 ) (* 16 x2 ) (* 15 x4 ) (* 49 x2 ) (* 35 x4 ) ) (- 30)) )) +(assert (not (>= (+ (* (- 18) x4 ) (* 27 x4 ) ) 12)) ) +(assert (> (+ (* 42 x4 ) (* 10 x1 ) (* (- 3) x2 ) (* (- 38) x0 ) (* 49 x3 ) (* (- 8) x4 ) ) 1) ) +(check-sat) +(pop 1) +(assert (or (not (< (+ (* 27 x0 ) (* (- 19) x4 ) (* (- 7) x2 ) (* 41 x1 ) (* (- 9) x4 ) (* (- 37) x1 ) (* 47 x4 ) (* 3 x0 ) ) 46)) (not (>= (+ (* 45 x2 ) (* 35 x3 ) (* (- 20) x1 ) ) 6)) )) +(check-sat) +(push 1) +(assert (>= (+ (* (- 10) x3 ) (* (- 29) x3 ) (* 39 x3 ) (* (- 6) x0 ) (* 16 x0 ) (* (- 1) x0 ) (* 34 x3 ) (* 24 x0 ) (* (- 44) x1 ) ) (- 41)) ) +(assert (< (+ (* (- 45) x3 ) (* 14 x2 ) (* (- 3) x0 ) (* (- 17) x3 ) (* 3 x2 ) (* (- 8) x2 ) ) (- 8)) ) +(check-sat) +(pop 1) +(assert (or (not (>= (+ (* (- 10) x0 ) (* (- 43) x3 ) (* (- 46) x1 ) (* (- 43) x2 ) (* (- 38) x4 ) (* (- 48) x3 ) (* (- 13) x2 ) (* (- 26) x1 ) (* (- 28) x0 ) (* 22 x3 ) (* 15 x0 ) ) (- 35))) (>= (+ (* 0 x1 ) (* (- 38) x0 ) ) 21) )) +(assert (or (> (+ (* (- 3) x1 ) (* 20 x0 ) (* (- 41) x4 ) (* (- 21) x4 ) (* 40 x1 ) (* 33 x3 ) ) 14) (<= (+ (* (- 27) x0 ) (* (- 45) x2 ) (* (- 20) x4 ) (* (- 46) x2 ) (* 28 x2 ) ) (- 13)) )) +(assert (or (<= (+ (* 14 x2 ) (* (- 14) x2 ) (* 11 x0 ) (* (- 26) x2 ) (* (- 27) x4 ) (* 18 x2 ) (* (- 35) x1 ) (* 17 x0 ) (* (- 28) x3 ) ) (- 26)) (not (> (+ (* (- 3) x1 ) (* (- 37) x3 ) (* (- 41) x3 ) (* (- 50) x3 ) (* (- 30) x2 ) (* (- 36) x0 ) (* (- 8) x3 ) (* 28 x1 ) (* 30 x1 ) (* 24 x1 ) (* (- 11) x3 ) ) 39)) (<= (+ (* 32 x3 ) (* 38 x1 ) (* (- 23) x2 ) (* 32 x3 ) (* 36 x3 ) (* 38 x2 ) (* 19 x2 ) (* (- 46) x0 ) (* (- 30) x0 ) (* (- 39) x1 ) (* 15 x3 ) ) (- 7)) )) +(assert (or (not (<= (+ (* 47 x0 ) (* (- 10) x0 ) (* 14 x2 ) (* (- 49) x4 ) (* 19 x1 ) (* (- 14) x4 ) ) 5)) (>= (+ (* (- 14) x2 ) (* 34 x0 ) (* (- 1) x4 ) (* (- 43) x3 ) (* 41 x4 ) (* 3 x4 ) (* 0 x2 ) (* (- 6) x3 ) (* (- 4) x4 ) (* 33 x0 ) ) (- 40)) (not (> (+ (* (- 29) x0 ) (* 40 x2 ) (* (- 32) x4 ) (* 48 x2 ) (* 37 x2 ) (* (- 34) x2 ) (* (- 20) x1 ) (* 0 x0 ) ) 24)) )) +(assert (or (< (+ (* (- 14) x3 ) (* (- 7) x4 ) (* (- 1) x4 ) ) (- 41)) (< (+ (* (- 2) x0 ) (* 24 x3 ) (* 25 x2 ) (* (- 24) x4 ) (* (- 43) x3 ) (* 49 x4 ) ) 39) )) +(assert (or (= (+ (* 42 x2 ) (* (- 15) x0 ) (* 39 x3 ) (* (- 2) x0 ) (* 41 x0 ) ) (- 46)) (not (<= (+ (* (- 25) x0 ) (* (- 38) x1 ) (* (- 17) x1 ) (* (- 34) x0 ) (* 34 x0 ) (* 31 x2 ) (* 19 x1 ) ) (- 5))) )) +(assert (or (< (+ (* (- 15) x1 ) (* 41 x1 ) (* (- 37) x0 ) (* (- 11) x4 ) (* (- 29) x0 ) (* 6 x1 ) ) 48) (< (+ (* (- 39) x3 ) (* 5 x2 ) ) (- 3)) )) +(assert (or (< (+ (* 37 x4 ) (* (- 24) x2 ) (* 18 x1 ) (* (- 6) x1 ) (* 46 x1 ) (* (- 5) x2 ) (* 18 x0 ) ) (- 32)) (= (+ (* 46 x4 ) (* (- 48) x0 ) (* 38 x4 ) (* 9 x2 ) (* 43 x0 ) (* 33 x4 ) (* 34 x2 ) (* 36 x3 ) (* (- 6) x0 ) (* (- 27) x2 ) (* (- 32) x0 ) ) (- 31)) )) +(assert (or (not (< (+ (* 43 x0 ) (* 4 x0 ) (* 26 x0 ) (* (- 1) x3 ) (* 15 x1 ) (* (- 7) x3 ) (* (- 25) x1 ) (* (- 12) x1 ) ) (- 41))) (< (+ (* 33 x2 ) (* (- 13) x4 ) (* 15 x2 ) ) 37) (not (>= (+ (* 41 x1 ) (* 14 x3 ) ) 47)) )) +(assert (or (not (< (+ (* 0 x3 ) (* (- 16) x4 ) (* 27 x0 ) (* 34 x4 ) (* (- 49) x1 ) (* 30 x2 ) (* 3 x4 ) (* (- 12) x3 ) ) 20)) (> (+ (* 19 x1 ) (* 9 x1 ) (* (- 16) x3 ) (* 23 x4 ) (* (- 9) x2 ) (* (- 35) x1 ) (* (- 18) x1 ) (* 16 x2 ) (* 28 x1 ) ) (- 48)) (not (>= (+ (* 18 x3 ) (* (- 7) x4 ) (* 34 x1 ) (* (- 31) x0 ) ) (- 21))) )) +(check-sat) +(push 1) +(assert (or (not (<= (+ (* 44 x4 ) (* 15 x2 ) (* 9 x2 ) (* 9 x1 ) (* 24 x1 ) ) (- 30))) (<= (+ (* (- 13) x1 ) (* 41 x3 ) ) 1) (= (+ (* 19 x0 ) (* 48 x2 ) (* 33 x2 ) (* 28 x1 ) (* (- 2) x3 ) ) (- 26)) )) +(assert (or (= (+ (* (- 2) x0 ) (* 32 x3 ) (* (- 25) x0 ) ) (- 3)) (= (+ (* 16 x0 ) (* (- 45) x0 ) (* (- 43) x3 ) (* 20 x4 ) (* (- 19) x1 ) ) (- 45)) (not (> (+ (* 35 x2 ) (* (- 7) x2 ) (* 4 x3 ) (* 48 x2 ) (* 15 x4 ) (* (- 4) x2 ) (* 30 x2 ) (* 7 x4 ) (* (- 34) x4 ) (* 42 x0 ) (* 30 x3 ) ) 49)) )) +(assert (> (+ (* (- 7) x0 ) (* 14 x4 ) (* (- 34) x0 ) (* 18 x4 ) (* (- 22) x0 ) (* 26 x3 ) (* 1 x4 ) ) (- 28)) ) +(assert (or (not (= (+ (* 22 x2 ) (* (- 24) x1 ) (* 46 x0 ) (* (- 42) x0 ) (* (- 42) x3 ) (* (- 10) x3 ) ) (- 47))) (not (>= (+ (* (- 34) x4 ) (* 6 x2 ) (* 21 x0 ) (* 41 x3 ) (* (- 43) x4 ) (* 7 x4 ) (* (- 21) x1 ) (* (- 6) x1 ) (* 8 x1 ) ) (- 28))) )) +(assert (>= (+ (* (- 15) x2 ) (* (- 39) x0 ) (* (- 45) x4 ) (* 40 x2 ) (* 49 x3 ) (* (- 32) x2 ) (* (- 18) x2 ) (* (- 2) x4 ) (* (- 9) x4 ) ) (- 45)) ) +(assert (or (not (> (+ (* (- 1) x2 ) (* 33 x2 ) (* (- 50) x3 ) (* 6 x2 ) (* (- 8) x2 ) (* (- 6) x4 ) (* 16 x4 ) (* 23 x4 ) (* 31 x2 ) (* 42 x3 ) (* (- 45) x0 ) ) (- 10))) (> (+ (* 18 x0 ) (* (- 31) x2 ) (* (- 4) x3 ) (* 27 x0 ) (* 18 x4 ) (* (- 27) x0 ) (* 19 x1 ) (* (- 3) x3 ) (* 19 x3 ) ) 15) (> (+ (* (- 12) x1 ) (* (- 3) x2 ) (* (- 31) x0 ) (* 43 x1 ) (* 46 x2 ) (* 36 x3 ) (* 6 x0 ) (* (- 15) x4 ) (* 15 x1 ) (* 18 x0 ) ) 39) )) +(assert (not (< (+ (* 47 x3 ) (* (- 27) x1 ) (* (- 18) x2 ) (* 9 x3 ) (* (- 42) x1 ) (* 37 x3 ) (* (- 2) x1 ) (* (- 36) x0 ) (* 0 x1 ) (* 21 x2 ) (* 10 x2 ) ) (- 14))) ) +(assert (or (not (< (+ (* 10 x1 ) (* 15 x4 ) (* (- 30) x2 ) (* 39 x0 ) (* (- 45) x4 ) (* (- 14) x3 ) (* 29 x3 ) (* 16 x0 ) (* (- 39) x4 ) ) (- 18))) (not (>= (+ (* 1 x3 ) (* (- 25) x2 ) (* 45 x1 ) (* (- 25) x2 ) (* 41 x3 ) (* (- 16) x0 ) (* (- 7) x3 ) ) 4)) (< (+ (* 35 x3 ) (* (- 32) x4 ) (* 24 x4 ) (* 45 x4 ) (* (- 34) x2 ) (* 1 x0 ) (* (- 49) x2 ) (* 39 x4 ) (* (- 48) x1 ) (* 30 x2 ) ) (- 23)) )) +(check-sat) +(pop 1) +(assert (or (not (> (+ (* (- 6) x4 ) (* 34 x4 ) (* (- 45) x4 ) (* (- 5) x2 ) (* 36 x0 ) (* (- 33) x0 ) (* 2 x4 ) (* (- 21) x0 ) (* 24 x3 ) (* (- 19) x3 ) (* (- 43) x1 ) ) (- 38))) (<= (+ (* 49 x0 ) (* (- 19) x2 ) (* (- 4) x4 ) (* (- 49) x2 ) (* 6 x1 ) (* 35 x1 ) (* 36 x3 ) ) (- 26)) )) +(assert (< (+ (* (- 47) x2 ) (* 28 x1 ) (* 29 x0 ) (* 49 x2 ) (* 49 x0 ) (* (- 43) x4 ) (* 3 x0 ) (* (- 5) x3 ) (* 16 x0 ) (* 33 x1 ) ) 24) ) +(check-sat) +(push 1) +(assert (or (> (+ (* (- 27) x4 ) (* (- 23) x3 ) (* (- 23) x2 ) (* 10 x0 ) (* (- 40) x2 ) ) 48) (not (= (+ (* 6 x2 ) (* (- 49) x3 ) (* (- 5) x1 ) ) 3)) (not (> (+ (* (- 3) x4 ) (* (- 31) x3 ) (* 3 x0 ) (* (- 9) x4 ) (* 18 x1 ) (* 8 x1 ) ) 45)) )) +(assert (or (not (< (+ (* (- 40) x2 ) (* (- 29) x3 ) (* (- 32) x3 ) (* 15 x4 ) (* (- 23) x0 ) (* 8 x4 ) (* (- 30) x2 ) (* 26 x3 ) (* (- 2) x1 ) (* (- 14) x1 ) (* 7 x2 ) ) 6)) (not (> (+ (* (- 12) x4 ) (* 30 x4 ) (* 36 x1 ) (* (- 20) x2 ) (* 11 x2 ) ) (- 50))) )) +(assert (or (not (= (+ (* 31 x1 ) (* 34 x3 ) (* (- 31) x2 ) (* (- 12) x0 ) (* 29 x2 ) (* 13 x2 ) (* 16 x2 ) (* (- 42) x3 ) (* 32 x2 ) (* 18 x3 ) ) 18)) (> (+ (* (- 47) x4 ) (* 20 x2 ) (* (- 27) x1 ) ) (- 21)) )) +(assert (> (+ (* 21 x4 ) (* (- 14) x3 ) (* (- 48) x0 ) (* (- 6) x2 ) (* 20 x4 ) (* 28 x4 ) (* 43 x3 ) (* 23 x1 ) (* 47 x1 ) ) (- 49)) ) +(assert (> (+ (* 21 x4 ) (* 45 x2 ) (* 8 x1 ) (* (- 40) x1 ) (* (- 34) x1 ) (* (- 19) x1 ) (* 0 x1 ) ) (- 23)) ) +(assert (< (+ (* (- 34) x2 ) (* (- 45) x4 ) (* 3 x0 ) (* (- 33) x2 ) ) 18) ) +(assert (or (<= (+ (* 25 x2 ) (* (- 30) x0 ) (* 7 x0 ) (* 34 x1 ) (* (- 43) x0 ) (* 18 x4 ) (* (- 43) x4 ) (* 19 x2 ) (* (- 21) x3 ) (* 35 x3 ) (* 5 x4 ) ) (- 12)) (not (> (+ (* (- 33) x2 ) (* 26 x3 ) (* (- 25) x4 ) ) (- 46))) )) +(check-sat) +(pop 1) +(assert (or (not (>= (+ (* (- 38) x3 ) (* (- 6) x4 ) (* (- 19) x4 ) (* (- 45) x1 ) (* (- 46) x2 ) ) 40)) (not (<= (+ (* (- 14) x1 ) (* 45 x3 ) (* (- 42) x4 ) (* 38 x2 ) (* 26 x0 ) (* 32 x0 ) (* 19 x2 ) (* 45 x1 ) (* 11 x1 ) (* (- 38) x2 ) ) (- 45))) )) +(assert (not (> (+ (* 27 x2 ) (* (- 11) x4 ) (* (- 30) x2 ) ) (- 23))) ) +(assert (or (<= (+ (* 44 x2 ) (* (- 26) x3 ) (* (- 13) x1 ) ) 44) (= (+ (* 41 x0 ) (* 13 x4 ) (* (- 15) x2 ) (* (- 41) x4 ) (* (- 36) x4 ) (* 5 x2 ) ) (- 45)) (not (= (+ (* 41 x1 ) (* (- 45) x1 ) (* 38 x3 ) (* 1 x4 ) (* 25 x2 ) (* 8 x4 ) (* 23 x0 ) (* 27 x2 ) ) 15)) )) +(assert (or (= (+ (* (- 42) x3 ) (* 37 x1 ) (* 48 x3 ) (* 41 x4 ) (* (- 18) x0 ) (* (- 2) x2 ) (* (- 32) x2 ) (* (- 14) x1 ) (* (- 49) x4 ) (* 8 x4 ) (* 34 x1 ) ) 34) (not (< (+ (* 4 x3 ) (* (- 8) x0 ) (* (- 10) x1 ) (* 24 x3 ) (* (- 32) x3 ) (* 14 x2 ) (* 4 x4 ) (* (- 6) x1 ) (* (- 16) x3 ) (* 41 x2 ) (* (- 19) x2 ) ) 42)) (< (+ (* (- 24) x2 ) (* (- 14) x2 ) (* (- 15) x2 ) (* (- 31) x0 ) (* 21 x2 ) (* (- 18) x4 ) (* (- 11) x0 ) (* 19 x1 ) ) (- 47)) )) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_5_6.smt2 b/test/regress/regress1/push-pop/fuzz_5_6.smt2 new file mode 100644 index 000000000..1cffc92cb --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_5_6.smt2 @@ -0,0 +1,49 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LRA) +(declare-fun x0 () Real) +(declare-fun x1 () Real) +(declare-fun x2 () Real) +(declare-fun x3 () Real) +(declare-fun x4 () Real) +(assert (or (= (+ (* 24 x2 ) (* (- 12) x4 ) (* (- 11) x2 ) (* 21 x1 ) ) (- 25)) (not (< (+ (* (- 42) x2 ) (* 19 x2 ) (* (- 48) x1 ) (* 37 x0 ) ) 38)) )) +(assert (< (+ (* (- 40) x2 ) (* 1 x3 ) (* (- 30) x4 ) (* (- 45) x2 ) (* 39 x3 ) ) (- 6)) ) +(assert (or (not (> (+ (* 26 x0 ) (* (- 42) x1 ) (* (- 40) x2 ) (* (- 33) x0 ) (* 1 x2 ) (* (- 5) x4 ) (* 46 x4 ) (* 13 x1 ) (* (- 49) x4 ) (* (- 22) x4 ) (* (- 6) x1 ) ) (- 16))) (not (<= (+ (* 48 x3 ) (* 27 x0 ) (* (- 23) x2 ) (* (- 35) x3 ) ) 37)) (not (<= (+ (* 25 x0 ) (* 16 x1 ) (* 47 x2 ) (* (- 22) x0 ) ) 10)) )) +(assert (>= (+ (* 38 x0 ) (* 6 x1 ) (* (- 48) x1 ) (* (- 27) x4 ) (* 33 x1 ) (* (- 14) x2 ) (* 40 x4 ) (* 26 x3 ) ) 42) ) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (<= (+ (* (- 32) x2 ) (* 30 x1 ) (* 41 x2 ) (* (- 37) x1 ) ) (- 21)) (< (+ (* 9 x0 ) (* (- 1) x2 ) (* 48 x1 ) (* (- 47) x0 ) (* (- 22) x4 ) (* 49 x0 ) (* (- 10) x4 ) (* 9 x1 ) (* (- 30) x4 ) (* 38 x2 ) (* 5 x0 ) ) 19) )) +(check-sat) +(push 1) +(assert (or (< (+ (* 9 x4 ) (* 25 x1 ) (* 47 x4 ) (* (- 26) x1 ) (* (- 10) x2 ) (* 28 x3 ) (* (- 37) x2 ) (* (- 22) x2 ) (* 23 x1 ) (* (- 36) x2 ) ) (- 10)) (< (+ (* (- 31) x2 ) (* (- 6) x4 ) (* (- 28) x4 ) (* 13 x0 ) (* 21 x4 ) ) 40) )) +(check-sat) +(pop 1) +(assert (not (> (+ (* (- 44) x3 ) (* (- 40) x3 ) (* (- 46) x4 ) (* (- 1) x4 ) (* 26 x3 ) (* (- 27) x4 ) (* 26 x4 ) (* 21 x4 ) (* 44 x0 ) (* (- 3) x3 ) ) (- 41))) ) +(assert (or (not (< (+ (* 22 x2 ) (* (- 4) x0 ) ) (- 28))) (<= (+ (* 41 x1 ) (* 7 x4 ) ) (- 10)) )) +(assert (not (<= (+ (* (- 21) x2 ) (* (- 6) x3 ) (* (- 24) x3 ) (* (- 17) x1 ) (* 11 x1 ) (* (- 5) x0 ) ) (- 45))) ) +(assert (or (< (+ (* 16 x2 ) (* 48 x3 ) (* 20 x2 ) (* (- 1) x2 ) (* 43 x0 ) (* 15 x0 ) (* (- 33) x0 ) ) 44) (not (<= (+ (* (- 46) x4 ) (* 22 x0 ) (* (- 10) x3 ) (* (- 27) x0 ) (* (- 11) x4 ) (* (- 32) x0 ) (* 17 x3 ) (* (- 39) x4 ) (* (- 8) x3 ) (* (- 25) x1 ) ) (- 7))) )) +(check-sat) +(push 1) +(check-sat) +(pop 1) +(assert (or (not (< (+ (* (- 5) x2 ) (* (- 22) x3 ) (* 2 x0 ) (* 42 x1 ) (* (- 29) x2 ) (* 12 x3 ) (* 16 x3 ) (* (- 19) x0 ) (* (- 42) x0 ) (* (- 6) x1 ) ) 40)) (> (+ (* 27 x2 ) (* (- 28) x2 ) (* 7 x0 ) (* 9 x1 ) (* 14 x2 ) (* 4 x3 ) (* (- 16) x3 ) (* 41 x1 ) ) (- 42)) )) +(assert (or (= (+ (* (- 36) x4 ) (* 5 x0 ) (* 2 x4 ) ) (- 16)) (< (+ (* (- 10) x1 ) (* 13 x3 ) (* 39 x4 ) (* (- 47) x3 ) (* (- 39) x0 ) (* 24 x2 ) (* 5 x2 ) (* (- 45) x2 ) (* 24 x1 ) ) (- 21)) )) +(check-sat) +(push 1) +(assert (or (< (+ (* (- 7) x3 ) (* 35 x2 ) (* (- 42) x1 ) (* 43 x3 ) (* 27 x3 ) (* (- 47) x2 ) (* (- 5) x2 ) (* 13 x0 ) (* 36 x4 ) ) (- 38)) (not (<= (+ (* 27 x0 ) (* 25 x1 ) (* 36 x0 ) (* 46 x2 ) (* (- 9) x2 ) (* 4 x1 ) (* (- 6) x3 ) (* (- 6) x4 ) (* (- 22) x2 ) (* (- 19) x3 ) (* (- 25) x3 ) ) (- 22))) )) +(assert (or (= (+ (* (- 13) x3 ) (* 3 x4 ) (* (- 25) x2 ) (* (- 26) x0 ) ) (- 38)) (< (+ (* 13 x2 ) (* (- 44) x3 ) (* 12 x2 ) (* (- 6) x2 ) (* 25 x2 ) (* 27 x2 ) ) (- 50)) )) +(assert (or (not (= (+ (* (- 18) x4 ) (* (- 31) x1 ) ) (- 13))) (= (+ (* (- 42) x3 ) (* 10 x2 ) (* 29 x0 ) (* 0 x4 ) (* (- 19) x2 ) ) (- 38)) (= (+ (* (- 47) x4 ) (* (- 36) x1 ) (* 11 x1 ) (* (- 50) x1 ) (* 1 x0 ) (* (- 33) x3 ) (* 20 x2 ) (* (- 32) x2 ) (* (- 30) x0 ) (* 42 x2 ) (* (- 21) x1 ) ) 21) )) +(check-sat) +(pop 1) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/fuzz_6.smt2 b/test/regress/regress1/push-pop/fuzz_6.smt2 new file mode 100644 index 000000000..14e82a48a --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_6.smt2 @@ -0,0 +1,35 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(assert (and (or (or (or (not (and (and (or (and x2 x1) (and x0 x4)) (and (and x0 x2) (not x1))) (or (not (not x3)) (not (and x6 x0))))) (and (and (or (or (and x2 x0) (and x0 x0)) (and (and x1 x6) (not x6))) (or (not (and x1 x4)) (or (or x0 x0) (or x3 x0)))) (not (or (or (and x1 x2) (and x1 x4)) (not (and x3 x2)))))) (or (or (and (and (and (or x1 x4) (not x1)) (or (not x1) (and x4 x5))) (and (not (or x3 x2)) (and (not x4) (not x6)))) (or (not (not (not x6))) (not (not (or x0 x2))))) (and (and (or (or (or x6 x3) (or x3 x1)) (not (and x4 x1))) (and (not (or x1 x3)) (or (or x3 x4) (or x4 x1)))) (or (not (or (not x0) (and x4 x5))) (not (not (or x4 x4))))))) (or (not (or (or (and (or (not x1) (and x3 x3)) (not (or x4 x0))) (and (and (not x6) (and x6 x3)) (and (not x1) (not x6)))) (or (or (not (and x5 x0)) (or (not x1) (or x3 x0))) (and (not (and x0 x0)) (and (and x5 x6) (not x2)))))) (and (not (and (not (not (not x0))) (and (or (and x2 x2) (or x1 x4)) (or (and x1 x6) (and x5 x3))))) (and (not (not (not (or x0 x0)))) (or (or (and (or x0 x2) (or x5 x2)) (not (not x2))) (not (or (and x3 x2) (or x5 x3)))))))) (or (and (or (or (not (not (or (not x6) (and x1 x2)))) (not (and (not (and x1 x3)) (and (not x2) (and x1 x4))))) (not (or (and (and (or x1 x2) (or x0 x2)) (and (or x6 x6) (and x4 x0))) (and (and (or x0 x4) (or x6 x0)) (and (and x0 x2) (or x3 x6)))))) (or (and (or (or (and (and x4 x6) (or x2 x6)) (and (not x6) (or x6 x1))) (not (not (not x3)))) (or (and (not (and x5 x2)) (or (or x5 x1) (or x4 x6))) (and (not (or x3 x4)) (or (not x2) (not x2))))) (or (or (not (not (or x1 x1))) (and (not (or x6 x4)) (and (or x6 x1) (not x5)))) (and (and (not (or x0 x0)) (and (or x0 x6) (not x6))) (or (and (not x0) (or x2 x1)) (or (and x6 x3) (not x3))))))) (not (or (not (not (or (or (and x3 x0) (and x3 x5)) (and (or x3 x0) (and x3 x0))))) (not (or (not (or (or x6 x4) (not x5))) (not (or (and x5 x2) (and x4 x4)))))))))) +(assert (or x3 x5)) +(assert (or (and (not x1) (not x6)) (not (not x6)))) +(assert (not (not (and (and (or (or (and (not (or (or x0 x4) (and x4 x1))) (and (and (or x4 x5) (or x3 x1)) (or (not x0) (or x3 x4)))) (or (or (or (or x5 x5) (or x1 x4)) (or (and x5 x6) (not x1))) (or (or (or x2 x0) (or x0 x3)) (and (or x0 x4) (or x5 x6))))) (not (or (not (not (or x0 x2))) (and (and (and x0 x1) (and x0 x5)) (not (and x6 x0)))))) (and (not (or (not (or (or x2 x3) (and x6 x6))) (and (or (not x1) (or x2 x6)) (or (and x6 x4) (and x6 x5))))) (not (not (not (and (not x5) (or x1 x4))))))) (or (not (or (not (not (or (or x4 x0) (and x2 x6)))) (and (and (not (not x0)) (not (not x2))) (not (not (and x5 x6)))))) (or (and (and (and (or (not x4) (not x1)) (and (not x3) (not x1))) (not (and (not x1) (not x0)))) (or (or (or (or x3 x3) (not x3)) (or (not x0) (and x5 x5))) (or (not (and x0 x6)) (and (and x6 x1) (or x0 x3))))) (not (or (or (and (and x1 x5) (and x3 x6)) (and (not x0) (not x4))) (and (and (and x6 x0) (or x4 x0)) (or (and x0 x4) (not x5))))))))))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (and x2 x0)) +(check-sat) +(push 1) +(assert (and (not (and (or x3 x3) (and x6 x0))) (or (not (or x6 x4)) (or (or x1 x2) (and x4 x6))))) +(assert (and (not (or (and (and (and x4 x2) (not x3)) (or (or x5 x6) (not x2))) (not (or (not x0) (not x4))))) (or (or (not (or (not x0) (or x2 x2))) (and (and (not x5) (not x1)) (or (not x6) (not x5)))) (and (and (not (and x2 x1)) (not (or x6 x0))) (or (not (or x0 x2)) (not (and x1 x2))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (and (not (or (not (not x4)) (or (or x1 x6) (and x2 x4)))) (not (and (and (or x1 x1) (and x1 x6)) (not (not x2)))))) +(assert (not (not x3))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_7.smt2 b/test/regress/regress1/push-pop/fuzz_7.smt2 new file mode 100644 index 000000000..b39a6f88f --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_7.smt2 @@ -0,0 +1,42 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(declare-fun x9 () Bool) +(assert (and (and (or (or (and (not (and (and (or x9 x6) (or x8 x9)) (not (not x2)))) (and (not (and (and x3 x1) (or x7 x0))) (or (and (or x6 x7) (not x2)) (or (or x8 x8) (not x0))))) (and (or (and (or (or x7 x5) (or x2 x8)) (not (not x3))) (and (and (and x2 x0) (and x1 x9)) (and (and x7 x5) (or x8 x5)))) (and (or (and (or x3 x6) (and x9 x4)) (or (not x8) (and x2 x6))) (not (and (not x7) (or x6 x1)))))) (not (or (or (and (and (and x6 x2) (or x5 x9)) (not (not x2))) (or (or (and x5 x0) (or x3 x0)) (or (or x6 x9) (not x5)))) (or (not (or (not x0) (or x7 x7))) (not (or (and x6 x1) (not x1))))))) (or (and (or (and (not (or (or x4 x2) (and x4 x3))) (or (not (or x1 x7)) (not (not x7)))) (or (or (or (or x3 x0) (and x0 x2)) (and (not x1) (or x3 x8))) (not (or (not x3) (or x3 x0))))) (or (not (or (and (and x3 x7) (not x2)) (or (not x6) (or x8 x9)))) (not (not (or (and x1 x2) (and x6 x3)))))) (and (or (or (not (and (not x3) (not x0))) (and (and (not x4) (and x6 x6)) (and (and x4 x1) (not x3)))) (and (and (or (or x9 x9) (not x5)) (or (and x3 x0) (and x3 x2))) (not (or (not x9) (not x7))))) (or (or (or (or (not x4) (and x0 x2)) (not (or x1 x7))) (and (and (or x1 x8) (and x1 x1)) (and (or x7 x7) (or x0 x1)))) (and (and (not (not x3)) (or (or x2 x0) (not x4))) (and (not (not x8)) (or (and x0 x0) (not x8)))))))) (or (not (or (and (and (not (not (and x1 x2))) (and (not (not x5)) (or (not x9) (and x2 x8)))) (and (or (or (or x7 x1) (not x7)) (not (not x8))) (or (not (and x9 x9)) (or (not x3) (and x0 x0))))) (and (not (not (not (and x6 x6)))) (or (or (and (or x6 x6) (and x0 x9)) (not (not x1))) (or (or (not x2) (or x3 x5)) (or (or x7 x5) (and x1 x0))))))) (not (not (or (or (not (and (and x9 x4) (not x7))) (and (not (and x3 x7)) (and (and x4 x4) (and x1 x0)))) (and (and (and (or x3 x7) (or x5 x7)) (not (not x3))) (not (or (not x7) (or x6 x4)))))))))) +(check-sat) +(push 1) +(assert (not (or (or (and x3 x8) (or x4 x0)) (and (not x9) (and x6 x8))))) +(assert (not (and (and (or (or x9 x5) (and x4 x3)) (not (and x2 x9))) (and (or (and x3 x4) (not x4)) (and (and x0 x3) (or x6 x2)))))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (or (or (not x4) (and x9 x9)) (or (or x1 x5) (not x4))) (or (and (or x6 x0) (not x3)) (and (or x8 x7) (or x4 x4))))) +(check-sat) +(push 1) +(assert (or (and (and x9 x7) (or x8 x2)) (or (not x9) (or x6 x0)))) +(check-sat) +(pop 1) +(assert (and (not (not (not (and (not (or (not x4) (not x2))) (and (and (and x3 x1) (and x0 x0)) (or (not x2) (not x4))))))) (or (or (not (or (not (not (and x9 x0))) (and (and (not x0) (and x4 x4)) (or (not x0) (not x7))))) (or (or (not (not (and x8 x1))) (or (or (and x1 x3) (and x4 x4)) (or (not x6) (not x7)))) (and (not (and (not x5) (not x1))) (not (and (not x1) (not x2)))))) (or (not (and (and (and (or x0 x8) (not x5)) (not (or x0 x8))) (not (not (not x1))))) (or (not (and (or (and x3 x2) (and x7 x2)) (and (or x6 x8) (not x1)))) (and (and (or (and x0 x6) (and x5 x4)) (and (and x0 x6) (and x1 x0))) (or (or (not x7) (and x2 x3)) (not (or x2 x9))))))))) +(check-sat) +(push 1) +(assert (and (or (and (not (not (and (and x0 x4) (and x6 x4)))) (not (not (and (not x5) (not x9))))) (not (and (or (or (or x0 x1) (or x5 x5)) (not (not x6))) (and (or (and x2 x3) (and x3 x7)) (not (and x3 x3)))))) (or (not (not (or (not (not x8)) (and (not x7) (not x8))))) (not (or (not (not (or x8 x4))) (and (not (or x7 x6)) (not (and x5 x5)))))))) +(assert (not (or (and (and (or (or (or (and (not x4) (not x8)) (not (not x2))) (not (and (not x8) (or x6 x2)))) (not (not (or (and x7 x6) (and x0 x4))))) (or (or (not (not (and x3 x7))) (or (not (not x1)) (not (not x8)))) (and (not (or (not x6) (and x6 x8))) (or (and (not x4) (not x6)) (or (or x3 x1) (and x8 x3)))))) (or (and (not (or (not (and x7 x6)) (and (not x7) (and x5 x7)))) (not (and (not (and x6 x8)) (and (not x8) (not x5))))) (not (and (or (or (or x4 x0) (not x6)) (and (not x3) (not x8))) (not (and (not x1) (and x4 x9))))))) (and (or (and (and (and (and (and x9 x1) (not x9)) (or (or x5 x5) (not x7))) (or (and (not x5) (not x8)) (not (and x0 x1)))) (or (or (or (not x4) (or x1 x6)) (or (or x2 x0) (not x5))) (or (not (not x7)) (not (not x5))))) (or (and (not (or (and x1 x3) (or x1 x7))) (or (or (not x0) (not x6)) (or (not x9) (and x0 x0)))) (and (or (or (or x8 x1) (or x5 x8)) (or (or x1 x7) (and x2 x2))) (not (and (and x5 x9) (and x5 x8)))))) (or (not (and (and (and (or x4 x2) (and x8 x5)) (not (and x2 x2))) (not (not (not x3))))) (and (and (or (or (and x3 x3) (not x2)) (not (or x2 x6))) (or (and (and x9 x1) (not x1)) (not (and x6 x8)))) (not (not (or (not x2) (or x4 x1)))))))))) +(assert (and (not x4) (not x3))) +(assert (and (or x8 x9) (not x1))) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_8.smt2 b/test/regress/regress1/push-pop/fuzz_8.smt2 new file mode 100644 index 000000000..a12773352 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_8.smt2 @@ -0,0 +1,45 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(check-sat) +(push 1) +(assert (or (or (and (and (and (not (and (or (not (or x1 x0)) (not (and x4 x3))) (and (or (not x1) (and x1 x5)) (or (and x4 x5) (and x0 x2))))) (and (and (or (and (or x5 x0) (not x2)) (or (not x1) (or x5 x0))) (not (or (or x3 x2) (and x2 x1)))) (and (or (not (not x0)) (and (or x1 x0) (not x4))) (and (not (or x1 x5)) (or (and x0 x2) (or x5 x3)))))) (not (not (or (or (not (not x3)) (or (or x0 x3) (or x4 x5))) (or (not (not x5)) (and (and x3 x1) (or x0 x5))))))) (not (or (and (not (or (not (or x0 x5)) (or (and x1 x0) (and x2 x4)))) (not (not (and (and x0 x0) (and x0 x4))))) (not (and (and (not (and x1 x2)) (or (or x2 x0) (or x3 x4))) (not (or (not x4) (not x2)))))))) (and (and (and (or (not (or (or (or x5 x1) (not x5)) (or (and x2 x0) (not x4)))) (or (or (or (and x4 x3) (not x0)) (not (or x2 x5))) (not (or (or x4 x1) (and x5 x3))))) (not (and (not (not (or x3 x1))) (not (and (and x3 x1) (not x2)))))) (not (or (or (not (and (not x5) (and x2 x5))) (not (and (or x3 x2) (or x4 x2)))) (and (and (and (not x2) (not x4)) (or (and x0 x4) (or x2 x1))) (and (not (or x0 x3)) (and (and x3 x3) (and x4 x5))))))) (or (and (or (and (or (not (or x2 x5)) (not (not x2))) (or (or (not x1) (not x2)) (or (and x5 x5) (not x2)))) (or (and (and (and x3 x2) (and x0 x1)) (not (not x5))) (not (or (and x4 x0) (and x0 x4))))) (not (or (or (not (not x4)) (or (not x3) (or x2 x4))) (not (or (not x0) (and x2 x0)))))) (or (and (or (not (and (and x1 x2) (not x3))) (and (or (not x1) (or x3 x4)) (not (or x4 x0)))) (not (or (and (and x1 x5) (and x0 x1)) (not (or x2 x0))))) (not (or (not (and (or x4 x5) (not x2))) (or (and (or x0 x3) (or x4 x1)) (and (or x5 x0) (not x4))))))))) (not (and (and (or (and (and (or (not (not x4)) (and (and x4 x0) (and x4 x2))) (and (or (or x5 x4) (and x3 x5)) (or (and x2 x4) (and x1 x3)))) (or (not (and (and x2 x5) (and x4 x3))) (or (not (not x3)) (and (and x3 x3) (and x1 x2))))) (or (not (or (not (not x2)) (not (or x3 x1)))) (and (and (or (or x1 x2) (not x2)) (and (or x0 x5) (and x1 x3))) (not (not (and x5 x0)))))) (or (not (or (and (or (and x3 x3) (not x5)) (and (not x4) (and x2 x5))) (not (or (not x3) (or x0 x0))))) (and (and (and (not (and x3 x1)) (not (and x4 x0))) (or (and (not x1) (and x1 x0)) (or (or x5 x3) (and x2 x2)))) (and (not (or (not x2) (and x4 x2))) (not (and (or x3 x5) (or x1 x1))))))) (and (and (or (or (or (not (and x1 x4)) (or (and x1 x1) (and x3 x5))) (or (or (and x4 x4) (or x4 x4)) (and (and x5 x4) (not x1)))) (or (or (not (and x0 x3)) (and (or x3 x2) (or x1 x3))) (and (or (and x0 x2) (or x5 x4)) (not (and x2 x4))))) (or (or (or (not (or x2 x3)) (and (or x2 x3) (or x4 x3))) (and (and (or x1 x2) (and x1 x1)) (not (or x4 x5)))) (and (or (or (and x5 x1) (not x1)) (and (or x3 x5) (not x0))) (and (not (not x5)) (not (and x4 x5)))))) (not (and (and (and (or (and x2 x2) (and x2 x3)) (not (or x3 x0))) (or (not (not x1)) (or (and x4 x2) (not x3)))) (and (or (or (or x4 x3) (or x3 x3)) (not (and x2 x2))) (or (and (and x1 x1) (or x2 x5)) (and (and x2 x3) (not x3))))))))))) +(assert (and (not (not (not (or (and (and (not (and (not x5) (or x1 x1))) (not (or (or x2 x4) (not x0)))) (and (and (and (or x1 x4) (not x3)) (or (and x5 x0) (and x1 x0))) (not (not (not x4))))) (not (not (not (not (not x5))))))))) (not (or (not (and (not (not (not (and (and x0 x3) (or x5 x0))))) (and (and (not (and (and x4 x3) (or x1 x3))) (or (and (and x5 x0) (or x2 x0)) (or (and x4 x2) (and x0 x3)))) (or (or (and (and x3 x4) (or x0 x1)) (or (and x5 x0) (not x1))) (and (not (or x2 x5)) (and (not x1) (and x0 x1))))))) (not (or (not (or (and (or (and x0 x2) (and x5 x3)) (and (and x0 x3) (not x4))) (or (and (not x2) (not x0)) (and (or x2 x1) (not x1))))) (not (not (and (not (not x3)) (or (or x4 x0) (not x1))))))))))) +(check-sat) +(push 1) +(assert (not (not (not (or (or (or x3 x5) (or x2 x0)) (or (or x3 x4) (or x2 x4))))))) +(assert (and (and (or (not x5) (or x0 x3)) (or (and x2 x0) (or x0 x1))) (not (or (not x1) (and x4 x0))))) +(assert (or (not (or x4 x0)) (and (or x1 x3) (and x5 x3)))) +(check-sat) +(pop 1) +(check-sat) +(push 1) +(assert (or (not (or (not (not x1)) (and (or x5 x4) (and x3 x4)))) (not (not (not (and x3 x2)))))) +(assert (not (not (and x2 x4)))) +(check-sat) +(push 1) +(assert (and x3 x3)) +(assert (not (and (not x1) (and x0 x5)))) +(assert (not (and (not (or (and (and (or x2 x1) (not x3)) (and (not x2) (or x1 x1))) (and (and (not x4) (not x5)) (not (not x4))))) (not (or (and (and (not x5) (and x2 x0)) (or (and x3 x5) (or x0 x3))) (not (or (or x2 x4) (not x1)))))))) +(check-sat) +(pop 1) +(assert (not (or (or (or (not x0) (not x5)) (or (and x3 x5) (not x0))) (and (not (and x2 x0)) (and (not x1) (not x1)))))) +(assert (or (not x4) (or x3 x4))) +(assert (not (not (and (and (and x1 x4) (not x4)) (or (or x4 x3) (and x0 x2)))))) +(check-sat) +(pop 1) +(assert (not x1)) +(check-sat) diff --git a/test/regress/regress1/push-pop/fuzz_9.smt2 b/test/regress/regress1/push-pop/fuzz_9.smt2 new file mode 100644 index 000000000..3ed852966 --- /dev/null +++ b/test/regress/regress1/push-pop/fuzz_9.smt2 @@ -0,0 +1,55 @@ +; COMMAND-LINE: --incremental +; EXPECT: sat +; EXPECT: sat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: unsat +; EXPECT: sat +(set-logic QF_LIA) +(declare-fun x0 () Bool) +(declare-fun x1 () Bool) +(declare-fun x2 () Bool) +(declare-fun x3 () Bool) +(declare-fun x4 () Bool) +(declare-fun x5 () Bool) +(declare-fun x6 () Bool) +(declare-fun x7 () Bool) +(declare-fun x8 () Bool) +(assert (or (or (not (or (or (not (or (and x4 x4) (not x7))) (not (and (and x5 x7) (not x7)))) (and (and (and (and x6 x6) (not x0)) (not (or x3 x1))) (and (or (not x1) (and x5 x3)) (or (or x7 x6) (not x4)))))) (not (or (or (or (not (or x3 x7)) (not (and x2 x8))) (and (not (not x1)) (or (and x0 x3) (or x2 x5)))) (or (or (or (and x8 x1) (or x3 x0)) (and (not x5) (and x8 x6))) (not (not (and x2 x5))))))) (not (not (and (not (or (or (not x7) (and x8 x2)) (not (or x6 x3)))) (not (and (not (and x8 x3)) (or (not x3) (or x8 x2))))))))) +(check-sat) +(push 1) +(assert (and (and (or (or (and (and (or x1 x5) (not x8)) (and (not x8) (and x0 x8))) (or (or (and x0 x3) (and x0 x6)) (and (or x7 x7) (and x7 x0)))) (or (and (or (and x8 x7) (or x3 x2)) (not (not x7))) (not (and (not x8) (not x5))))) (or (or (and (and (or x2 x6) (or x7 x4)) (and (or x4 x3) (not x5))) (and (or (not x2) (or x2 x7)) (not (and x8 x7)))) (and (and (and (and x5 x4) (not x3)) (not (not x8))) (or (and (or x6 x1) (or x0 x7)) (not (and x8 x4)))))) (and (not (and (or (not (or x5 x5)) (and (and x6 x3) (or x0 x0))) (and (not (or x0 x0)) (and (not x6) (and x8 x6))))) (or (and (not (not (and x3 x8))) (or (not (not x0)) (and (and x5 x6) (or x0 x4)))) (or (and (and (not x2) (not x0)) (and (and x4 x2) (or x1 x6))) (or (and (not x5) (not x8)) (not (and x5 x3)))))))) +(check-sat) +(push 1) +(assert (and (or x7 x5) (and x2 x6))) +(check-sat) +(push 1) +(check-sat) +(push 1) +(assert (not (and x1 x6))) +(assert (or x7 x7)) +(assert (not (or x0 x7))) +(check-sat) +(push 1) +(assert (and (not (or (or (and x6 x2) (or x2 x8)) (or (and x7 x3) (or x2 x5)))) (and (or (not (not x4)) (and (not x4) (not x2))) (not (not (or x1 x7)))))) +(assert (not (and (or (and (and (not (and x6 x1)) (or (and x5 x3) (or x3 x1))) (or (or (not x2) (or x0 x1)) (not (or x7 x5)))) (not (or (not (not x8)) (and (not x4) (and x5 x8))))) (not (or (or (or (or x1 x1) (and x2 x3)) (and (and x5 x8) (not x7))) (and (not (or x5 x8)) (or (not x5) (and x2 x2)))))))) +(assert (not x4)) +(assert (not (and (not (or (not (or (not (or x8 x1)) (or (not x6) (not x4)))) (or (or (and (and x0 x7) (or x2 x7)) (or (or x7 x3) (and x5 x2))) (or (or (and x7 x0) (and x1 x1)) (and (not x7) (or x6 x7)))))) (or (and (and (and (not (not x0)) (and (or x7 x4) (or x3 x6))) (not (not (not x6)))) (or (or (and (and x1 x5) (or x7 x5)) (not (and x2 x3))) (not (or (not x8) (and x1 x8))))) (not (and (not (and (not x8) (and x1 x6))) (or (and (and x0 x0) (not x0)) (not (not x7))))))))) +(assert (or x1 x2)) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (not (and (not x5) (not x7))) (and (or (not x1) (and x4 x1)) (not (and x5 x8)))))) +(assert (not (and (or (and (not (and (and (not (or (not x5) (and x4 x7))) (and (and (and x6 x1) (not x3)) (not (and x5 x1)))) (and (or (or (or x7 x2) (or x2 x6)) (not (not x2))) (and (and (not x6) (and x4 x8)) (and (not x5) (or x1 x6)))))) (or (not (or (not (and (and x3 x5) (or x7 x3))) (or (not (not x7)) (not (not x0))))) (or (not (not (and (or x3 x6) (and x6 x2)))) (or (not (or (or x7 x3) (not x5))) (or (or (and x1 x2) (and x4 x2)) (not (not x7))))))) (and (not (not (or (not (or (not x0) (not x4))) (or (and (and x3 x2) (and x8 x3)) (and (not x1) (not x6)))))) (not (not (or (or (and (or x8 x3) (not x8)) (or (or x7 x5) (or x7 x7))) (and (or (or x4 x4) (or x3 x3)) (and (not x8) (not x7)))))))) (and (not (or (not (or (or (not (and x4 x4)) (or (and x5 x8) (or x5 x4))) (not (not (and x6 x3))))) (not (or (or (or (not x3) (or x5 x2)) (not (not x0))) (and (or (or x6 x4) (and x0 x3)) (and (not x2) (not x0))))))) (and (not (not (or (or (or (or x6 x6) (and x6 x8)) (or (or x1 x5) (or x8 x4))) (and (and (not x6) (or x8 x0)) (not (or x0 x5)))))) (or (not (not (or (or (not x0) (and x3 x4)) (or (and x3 x3) (not x2))))) (and (or (or (or (not x1) (not x0)) (not (or x0 x2))) (and (and (and x8 x7) (and x8 x2)) (or (or x7 x4) (and x1 x3)))) (or (or (or (or x8 x1) (or x8 x6)) (not (not x6))) (or (or (and x8 x7) (or x4 x6)) (and (not x3) (and x0 x0))))))))))) +(check-sat) +(pop 1) +(check-sat) +(pop 1) +(assert (not (and (and x7 x2) (or x4 x6)))) +(check-sat) +(push 1) diff --git a/test/regress/regress1/push-pop/quant-fun-proc-unmacro.smt2 b/test/regress/regress1/push-pop/quant-fun-proc-unmacro.smt2 new file mode 100644 index 000000000..7cacfca98 --- /dev/null +++ b/test/regress/regress1/push-pop/quant-fun-proc-unmacro.smt2 @@ -0,0 +1,34 @@ +; COMMAND-LINE: --incremental --fmf-fun --macros-quant --no-check-models +(set-logic UFLIA) + + +(define-fun f ((x Int)) Int x) + +(define-fun-rec g ((x Int)) Int (ite (<= x 0) 0 (+ (g x) x))) + +; EXPECT: sat +(declare-fun h (Int) Int) +(push 1) +(assert (forall ((x Int)) (= (h x) 0))) +(check-sat) +(pop 1) + + +; EXPECT: unsat +(push 1) +(assert (= (f 1) 2)) +(check-sat) +(pop 1) + +; EXPECT: unsat +(push 1) +(assert (= (g 1) 5)) +(check-sat) +(pop 1) + +; EXPECT: sat +(push 1) +(assert (= (h 1) 5)) +(check-sat) +(pop 1) + diff --git a/test/regress/regress1/push-pop/quant-fun-proc.smt2 b/test/regress/regress1/push-pop/quant-fun-proc.smt2 new file mode 100644 index 000000000..2a12cb677 --- /dev/null +++ b/test/regress/regress1/push-pop/quant-fun-proc.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --incremental --fmf-fun --macros-quant --macros-quant-mode=ground --no-check-models +(set-logic UFLIA) + +(define-fun f ((x Int)) Int x) + +(define-fun-rec g ((x Int)) Int (ite (<= x 0) 0 (+ (g x) x))) + +(declare-fun h (Int) Int) +(assert (forall ((x Int)) (= (h x) (+ x 3)))) + +; EXPECT: sat +(check-sat) + +; EXPECT: unsat +(push 1) +(assert (= (f 1) 2)) +(check-sat) +(pop 1) + +; EXPECT: unsat +(push 1) +(assert (= (g 1) 5)) +(check-sat) +(pop 1) + +; EXPECT: unsat +(push 1) +(assert (= (h 1) 5)) +(check-sat) +(pop 1) diff --git a/test/regress/regress1/quantifiers/006-cbqi-ite.smt2 b/test/regress/regress1/quantifiers/006-cbqi-ite.smt2 new file mode 100644 index 000000000..bfa3ef22b --- /dev/null +++ b/test/regress/regress1/quantifiers/006-cbqi-ite.smt2 @@ -0,0 +1,299 @@ +(set-logic LIA) +(set-info :status unsat) +(declare-fun W_S2_V6 () Bool) +(declare-fun W_S2_V4 () Bool) +(declare-fun W_S2_V2 () Bool) +(declare-fun W_S2_V3 () Bool) +(declare-fun W_S2_V1 () Bool) +(declare-fun W_S1_V6 () Bool) +(declare-fun W_S1_V5 () Bool) +(declare-fun W_S1_V2 () Bool) +(declare-fun W_S1_V3 () Bool) +(declare-fun W_S1_V1 () Bool) +(declare-fun R_S1_V1 () Bool) +(declare-fun R_S2_V6 () Bool) +(declare-fun R_S2_V4 () Bool) +(declare-fun R_S2_V5 () Bool) +(declare-fun R_S2_V2 () Bool) +(declare-fun R_S2_V3 () Bool) +(declare-fun R_S2_V1 () Bool) +(declare-fun R_E1_V6 () Bool) +(declare-fun R_E1_V4 () Bool) +(declare-fun R_E1_V5 () Bool) +(declare-fun R_E1_V2 () Bool) +(declare-fun R_E1_V3 () Bool) +(declare-fun R_E1_V1 () Bool) +(declare-fun DISJ_W_S2_R_E1 () Bool) +(declare-fun DISJ_W_S2_R_S2 () Bool) +(declare-fun R_S1_V6 () Bool) +(declare-fun R_S1_V4 () Bool) +(declare-fun R_S1_V5 () Bool) +(declare-fun R_S1_V2 () Bool) +(declare-fun R_S1_V3 () Bool) +(declare-fun DISJ_W_S2_R_S1 () Bool) +(declare-fun DISJ_W_S1_W_S2 () Bool) +(declare-fun DISJ_W_S1_R_E1 () Bool) +(declare-fun DISJ_W_S1_R_S2 () Bool) +(declare-fun DISJ_W_S1_R_S1 () Bool) +(declare-fun W_S2_V5 () Bool) +(declare-fun W_S1_V4 () Bool) +(assert + (let + (($x1615 + (forall + ((V1_0 Int) (V3_0 Int) + (V2_0 Int) (V5_0 Int) + (V4_0 Int) (V6_0 Int) + (MW_S1_V1 Bool) (MW_S1_V3 Bool) + (MW_S1_V2 Bool) (MW_S1_V5 Bool) + (MW_S1_V4 Bool) (MW_S1_V6 Bool) + (MW_S2_V1 Bool) (MW_S2_V3 Bool) + (MW_S2_V2 Bool) (MW_S2_V5 Bool) + (MW_S2_V4 Bool) (MW_S2_V6 Bool) + (S1_V1_!158 Int) (S1_V1_!171 Int) + (S2_V5_!167 Int) (S2_V5_!180 Int) + (S1_V3_!159 Int) (S1_V3_!172 Int) + (S1_V2_!160 Int) (S1_V2_!173 Int) + (E1_!157 Int) (E1_!170 Int) + (E1_!183 Int) (S2_V4_!168 Int) + (S2_V4_!181 Int) (S2_V6_!169 Int) + (S2_V6_!182 Int) (S1_V5_!161 Int) + (S1_V5_!174 Int) (S2_V1_!164 Int) + (S2_V1_!177 Int) (S1_V4_!162 Int) + (S1_V4_!175 Int) (S2_V3_!165 Int) + (S2_V3_!178 Int) (S2_V2_!166 Int) + (S2_V2_!179 Int) (S1_V6_!163 Int) + (S1_V6_!176 Int)) + (let ((?x1431 (ite MW_S1_V6 S1_V6_!176 V6_0))) + (let ((?x1432 (ite MW_S2_V6 S2_V6_!182 ?x1431))) + (let ((?x1433 (ite MW_S1_V6 S1_V6_!163 V6_0))) + (let ((?x1434 (ite MW_S2_V6 S2_V6_!169 ?x1433))) + (let (($x1435 (= ?x1434 ?x1432))) + (let ((?x1436 (ite MW_S1_V4 S1_V4_!175 V4_0))) + (let ((?x1437 (ite MW_S2_V4 S2_V4_!181 ?x1436))) + (let ((?x1438 (ite MW_S1_V4 S1_V4_!162 V4_0))) + (let ((?x1439 (ite MW_S2_V4 S2_V4_!168 ?x1438))) + (let (($x1440 (= ?x1439 ?x1437))) + (let ((?x1441 (ite MW_S1_V5 S1_V5_!174 V5_0))) + (let ((?x1442 (ite MW_S2_V5 S2_V5_!180 ?x1441))) + (let ((?x1444 (ite MW_S1_V5 S1_V5_!161 V5_0))) + (let ((?x1445 (ite MW_S2_V5 S2_V5_!167 ?x1444))) + (let (($x1446 (= ?x1445 ?x1442))) + (let ((?x1447 (ite MW_S1_V2 S1_V2_!173 V2_0))) + (let ((?x1448 (ite MW_S2_V2 S2_V2_!179 ?x1447))) + (let ((?x1449 (ite MW_S1_V2 S1_V2_!160 V2_0))) + (let ((?x1450 (ite MW_S2_V2 S2_V2_!166 ?x1449))) + (let (($x1451 (= ?x1450 ?x1448))) + (let ((?x1467 (ite MW_S1_V3 S1_V3_!159 V3_0))) + (let ((?x1468 (+ 1 ?x1467))) + (let ((?x1458 (ite MW_S2_V3 S2_V3_!165 ?x1468))) + (let + (($x1459 + (= ?x1458 + (+ (ite MW_S2_V3 S2_V3_!178 (ite MW_S1_V3 S1_V3_!172 V3_0)) ?x1448 + (* (- 1) E1_!183))))) + (let ((?x1460 (ite MW_S1_V1 S1_V1_!171 E1_!170))) + (let ((?x1487 (ite MW_S2_V1 S2_V1_!177 ?x1460))) + (let ((?x1453 (ite MW_S1_V1 S1_V1_!158 E1_!157))) + (let ((?x1489 (ite MW_S2_V1 S2_V1_!164 ?x1453))) + (let (($x1289 (= ?x1489 ?x1487))) + (let ((?x1455 (+ (- 1) ?x1448))) + (let (($x1376 (>= ?x1487 ?x1455))) + (let (($x1377 (<= V2_0 E1_!170))) + (let (($x1379 (not $x1377))) + (let ((?x1380 (+ (- 1) ?x1450))) + (let (($x1381 (>= ?x1489 ?x1380))) + (let (($x1479 (<= V2_0 E1_!157))) + (let (($x1456 (not $x1479))) + (let (($x1499 (and $x1456 $x1381 $x1379 $x1376))) + (let (($x1500 (not $x1499))) + (let (($x1502 (not MW_S2_V6))) + (let (($x1503 (or $x1502 W_S2_V6))) + (let (($x1504 (not MW_S2_V4))) + (let (($x1505 (or $x1504 W_S2_V4))) + (let (($x1508 (not MW_S2_V2))) + (let (($x1509 (or $x1508 W_S2_V2))) + (let (($x1510 (not MW_S2_V3))) + (let (($x1511 (or $x1510 W_S2_V3))) + (let (($x1512 (not MW_S2_V1))) + (let (($x1513 (or $x1512 W_S2_V1))) + (let (($x1514 (not MW_S1_V6))) + (let (($x1515 (or $x1514 W_S1_V6))) + (let (($x1518 (not MW_S1_V5))) + (let (($x1519 (or $x1518 W_S1_V5))) + (let (($x1520 (not MW_S1_V2))) + (let (($x1521 (or $x1520 W_S1_V2))) + (let (($x1522 (not MW_S1_V3))) + (let (($x1523 (or $x1522 W_S1_V3))) + (let (($x1524 (not MW_S1_V1))) + (let (($x1525 (or $x1524 W_S1_V1))) + (let (($x1527 (= S1_V6_!176 S1_V6_!163))) + (let (($x1528 (= E1_!170 E1_!157))) + (let (($x228 (not R_S1_V1))) + (let (($x1529 (or $x228 $x1528))) + (let (($x1530 (not $x1529))) + (let (($x1531 (or $x1530 $x1527))) + (let (($x1532 (= S2_V2_!179 S2_V2_!166))) + (let (($x1533 (= ?x1431 ?x1433))) + (let (($x253 (not R_S2_V6))) + (let (($x1534 (or $x253 $x1533))) + (let (($x1535 (= ?x1436 ?x1438))) + (let (($x251 (not R_S2_V4))) + (let (($x1536 (or $x251 $x1535))) + (let (($x1537 (= ?x1441 ?x1444))) + (let (($x249 (not R_S2_V5))) + (let (($x1538 (or $x249 $x1537))) + (let (($x1539 (= ?x1447 ?x1449))) + (let (($x247 (not R_S2_V2))) + (let (($x1540 (or $x247 $x1539))) + (let ((?x1462 (ite MW_S1_V3 S1_V3_!172 V3_0))) + (let (($x1541 (= ?x1462 ?x1468))) + (let (($x245 (not R_S2_V3))) + (let (($x1542 (or $x245 $x1541))) + (let (($x1543 (= ?x1460 ?x1453))) + (let (($x243 (not R_S2_V1))) + (let (($x1544 (or $x243 $x1543))) + (let (($x1545 (and $x1544 $x1542 $x1540 $x1538 $x1536 $x1534))) + (let (($x1546 (not $x1545))) + (let (($x1547 (or $x1546 $x1532))) + (let (($x1548 (= S2_V3_!165 S2_V3_!178))) + (let (($x1549 (= ?x1433 ?x1431))) + (let (($x1550 (or $x253 $x1549))) + (let (($x1551 (= ?x1438 ?x1436))) + (let (($x1552 (or $x251 $x1551))) + (let (($x1553 (= ?x1444 ?x1441))) + (let (($x1554 (or $x249 $x1553))) + (let (($x1555 (= ?x1449 ?x1447))) + (let (($x1556 (or $x247 $x1555))) + (let ((?x1557 (+ (- 1) ?x1462))) + (let (($x1558 (= ?x1467 ?x1557))) + (let (($x1559 (or $x245 $x1558))) + (let (($x1560 (= ?x1453 ?x1460))) + (let (($x1561 (or $x243 $x1560))) + (let (($x1562 (and $x1561 $x1559 $x1556 $x1554 $x1552 $x1550))) + (let (($x1563 (not $x1562))) + (let (($x1564 (or $x1563 $x1548))) + (let (($x1565 (= S1_V4_!175 S1_V4_!162))) + (let (($x1566 (or $x1530 $x1565))) + (let (($x1567 (= S2_V1_!177 S2_V1_!164))) + (let (($x1568 (or $x1546 $x1567))) + (let (($x1569 (= S1_V5_!174 S1_V5_!161))) + (let (($x1570 (or $x1530 $x1569))) + (let (($x1571 (= S2_V6_!182 S2_V6_!169))) + (let (($x1572 (or $x1546 $x1571))) + (let (($x1573 (= S2_V4_!168 S2_V4_!181))) + (let (($x1574 (or $x1563 $x1573))) + (let (($x1575 (= E1_!170 E1_!183))) + (let (($x1576 (= V6_0 ?x1432))) + (let (($x177 (not R_E1_V6))) + (let (($x1577 (or $x177 $x1576))) + (let (($x1578 (= V4_0 ?x1437))) + (let (($x175 (not R_E1_V4))) + (let (($x1579 (or $x175 $x1578))) + (let (($x1580 (= V5_0 ?x1442))) + (let (($x173 (not R_E1_V5))) + (let (($x1581 (or $x173 $x1580))) + (let (($x1582 (= V2_0 ?x1448))) + (let (($x171 (not R_E1_V2))) + (let (($x1583 (or $x171 $x1582))) + (let ((?x1463 (ite MW_S2_V3 S2_V3_!178 ?x1462))) + (let (($x1584 (= V3_0 ?x1463))) + (let (($x169 (not R_E1_V3))) + (let (($x1585 (or $x169 $x1584))) + (let ((?x1586 (+ 1 ?x1487))) + (let (($x1587 (= V1_0 ?x1586))) + (let (($x167 (not R_E1_V1))) + (let (($x1588 (or $x167 $x1587))) + (let (($x1589 (and $x1588 $x1585 $x1583 $x1581 $x1579 $x1577))) + (let (($x1590 (not $x1589))) + (let (($x1591 (or $x1590 $x1575))) + (let (($x1592 (= E1_!157 E1_!183))) + (let (($x1593 (or $x1590 $x1592))) + (let (($x1594 (= E1_!157 E1_!170))) + (let (($x1595 (= S1_V2_!173 S1_V2_!160))) + (let (($x1596 (or $x1530 $x1595))) + (let (($x1597 (= S1_V3_!159 S1_V3_!172))) + (let (($x1598 (or $x228 $x1594))) + (let (($x1599 (not $x1598))) + (let (($x1600 (or $x1599 $x1597))) + (let (($x1601 (= S2_V5_!180 S2_V5_!167))) + (let (($x1602 (or $x1546 $x1601))) + (let (($x1603 (= S1_V1_!158 S1_V1_!171))) + (let (($x1604 (or $x1599 $x1603))) + (let + (($x1612 + (and $x1604 $x1602 $x1600 $x1596 $x1594 $x1593 $x1591 $x1574 $x1572 + $x1570 $x1568 $x1566 $x1564 $x1547 $x1531 $x1525 $x1523 $x1521 $x1519 + $x1515 $x1513 $x1511 $x1509 $x1505 $x1503))) + (let (($x1613 (not $x1612))) + (or $x1613 $x1500 (and $x1289 $x1459 $x1451 $x1446 $x1440 $x1435))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + (let (($x103 (and W_S2_V6 R_E1_V6))) + (let (($x102 (and W_S2_V4 R_E1_V4))) + (let (($x100 (and W_S2_V2 R_E1_V2))) + (let (($x99 (and W_S2_V3 R_E1_V3))) + (let (($x98 (and W_S2_V1 R_E1_V1))) + (let (($x128 (or $x98 $x99 $x100 R_E1_V5 $x102 $x103))) + (let (($x129 (not $x128))) + (let (($x130 (= DISJ_W_S2_R_E1 $x129))) + (let (($x93 (and W_S2_V6 R_S2_V6))) + (let (($x92 (and W_S2_V4 R_S2_V4))) + (let (($x90 (and W_S2_V2 R_S2_V2))) + (let (($x89 (and W_S2_V3 R_S2_V3))) + (let (($x88 (and W_S2_V1 R_S2_V1))) + (let (($x125 (or $x88 $x89 $x90 R_S2_V5 $x92 $x93))) + (let (($x126 (not $x125))) + (let (($x127 (= DISJ_W_S2_R_S2 $x126))) + (let (($x83 (and W_S2_V6 R_S1_V6))) + (let (($x82 (and W_S2_V4 R_S1_V4))) + (let (($x80 (and W_S2_V2 R_S1_V2))) + (let (($x79 (and W_S2_V3 R_S1_V3))) + (let (($x78 (and W_S2_V1 R_S1_V1))) + (let (($x122 (or $x78 $x79 $x80 R_S1_V5 $x82 $x83))) + (let (($x123 (not $x122))) + (let (($x124 (= DISJ_W_S2_R_S1 $x123))) + (let (($x73 (and W_S1_V6 W_S2_V6))) + (let (($x68 (and W_S1_V2 W_S2_V2))) + (let (($x66 (and W_S1_V3 W_S2_V3))) + (let (($x64 (and W_S1_V1 W_S2_V1))) + (let (($x119 (or $x64 $x66 $x68 W_S1_V5 W_S2_V4 $x73))) + (let (($x120 (not $x119))) + (let (($x121 (= DISJ_W_S1_W_S2 $x120))) + (let (($x58 (and W_S1_V6 R_E1_V6))) + (let (($x54 (and W_S1_V5 R_E1_V5))) + (let (($x52 (and W_S1_V2 R_E1_V2))) + (let (($x50 (and W_S1_V3 R_E1_V3))) + (let (($x48 (and W_S1_V1 R_E1_V1))) + (let (($x116 (or $x48 $x50 $x52 $x54 R_E1_V4 $x58))) + (let (($x117 (not $x116))) + (let (($x118 (= DISJ_W_S1_R_E1 $x117))) + (let (($x42 (and W_S1_V6 R_S2_V6))) + (let (($x38 (and W_S1_V5 R_S2_V5))) + (let (($x36 (and W_S1_V2 R_S2_V2))) + (let (($x34 (and W_S1_V3 R_S2_V3))) + (let (($x32 (and W_S1_V1 R_S2_V1))) + (let (($x113 (or $x32 $x34 $x36 $x38 R_S2_V4 $x42))) + (let (($x114 (not $x113))) + (let (($x115 (= DISJ_W_S1_R_S2 $x114))) + (let (($x26 (and W_S1_V6 R_S1_V6))) + (let (($x21 (and W_S1_V5 R_S1_V5))) + (let (($x18 (and W_S1_V2 R_S1_V2))) + (let (($x15 (and W_S1_V3 R_S1_V3))) + (let (($x12 (and W_S1_V1 R_S1_V1))) + (let (($x110 (or $x12 $x15 $x18 $x21 R_S1_V4 $x26))) + (let (($x111 (not $x110))) + (let (($x112 (= DISJ_W_S1_R_S1 $x111))) + (and W_S1_V4 W_S2_V5 $x112 $x115 $x118 $x121 $x124 $x127 $x130 $x1615)))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(assert + (let (($x1192 (not W_S2_V2))) + (let (($x1189 (not W_S2_V3))) + (let (($x1186 (not W_S2_V1))) + (let (($x1091 (not W_S1_V2))) + (let (($x1078 (not W_S1_V1))) + (let (($x245 (not R_S2_V3))) + (let (($x167 (not R_E1_V1))) + (let + (($x1647 + (and $x167 $x245 $x1078 $x1091 $x1186 $x1189 $x1192 DISJ_W_S1_R_E1 + DISJ_W_S2_R_E1))) (not $x1647)))))))))) +(check-sat) + diff --git a/test/regress/regress1/quantifiers/AdditiveMethods_OwnedResults.Mz.smt2 b/test/regress/regress1/quantifiers/AdditiveMethods_OwnedResults.Mz.smt2 new file mode 100644 index 000000000..670dcc006 --- /dev/null +++ b/test/regress/regress1/quantifiers/AdditiveMethods_OwnedResults.Mz.smt2 @@ -0,0 +1,399 @@ +(set-logic AUFLIA) +(set-info :source | + Boogie/Spec# benchmarks. + This benchmark was translated by Michal Moskal. +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun boolIff (Int Int) Int) +(declare-fun PeerGroupPlaceholder_ () Int) +(declare-fun intGreater (Int Int) Int) +(declare-fun IfThenElse_ (Int Int Int) Int) +(declare-fun CONCVARSYM (Int) Int) +(declare-fun SharingMode_Unshared_ () Int) +(declare-fun OwnedResults.Mz_ (Int Int) Int) +(declare-fun System.Reflection.IReflect () Int) +(declare-fun int_m2147483648 () Int) +(declare-fun System.Int32 () Int) +(declare-fun intAtMost (Int Int) Int) +(declare-fun multiply (Int Int) Int) +(declare-fun Is_ (Int Int) Int) +(declare-fun Smt.true () Int) +(declare-fun ElementType_ (Int) Int) +(declare-fun divide (Int Int) Int) +(declare-fun int_m9223372036854775808 () Int) +(declare-fun divides (Int Int) Int) +(declare-fun select1 (Int Int) Int) +(declare-fun store1 (Int Int Int) Int) +(declare-fun select2 (Int Int Int) Int) +(declare-fun nullObject () Int) +(declare-fun store2 (Int Int Int Int) Int) +(declare-fun modulo (Int Int) Int) +(declare-fun ownerRef_ () Int) +(declare-fun StructSet_ (Int Int Int) Int) +(declare-fun AsDirectSubClass (Int Int) Int) +(declare-fun OwnedResults.Pw_ (Int Int) Int) +(declare-fun System.Boolean () Int) +(declare-fun shl_ (Int Int) Int) +(declare-fun DimLength_ (Int Int) Int) +(declare-fun block8823_correct () Int) +(declare-fun anyEqual (Int Int) Int) +(declare-fun System.Array () Int) +(declare-fun System.Reflection.ICustomAttributeProvider () Int) +(declare-fun SharingMode_LockProtected_ () Int) +(declare-fun IsMemberlessType_ (Int) Int) +(declare-fun System.UInt16 () Int) +(declare-fun ClassRepr (Int) Int) +(declare-fun System.Runtime.InteropServices._Type () Int) +(declare-fun boolNot (Int) Int) +(declare-fun T () Int) +(declare-fun System.Runtime.InteropServices._MemberInfo () Int) +(declare-fun boolAnd (Int Int) Int) +(declare-fun boolImplies (Int Int) Int) +(declare-fun Unbox (Int) Int) +(declare-fun intAtLeast (Int Int) Int) +(declare-fun ownerFrame_ () Int) +(declare-fun int_4294967295 () Int) +(declare-fun IsAllocated (Int Int) Int) +(declare-fun TypeName (Int) Int) +(declare-fun AsPeerField (Int) Int) +(declare-fun int_9223372036854775807 () Int) +(declare-fun block8840_correct () Int) +(declare-fun AsRepField (Int Int) Int) +(declare-fun System.Reflection.MemberInfo () Int) +(declare-fun ArrayCategoryValue_ () Int) +(declare-fun is (Int Int) Int) +(declare-fun InRange (Int Int) Bool) +(declare-fun AsOwner (Int Int) Int) +(declare-fun OwnedResults.Qz_System.Int32_ (Int Int Int) Int) +(declare-fun System.Int64 () Int) +(declare-fun or_ (Int Int) Int) +(declare-fun As_ (Int Int) Int) +(declare-fun exposeVersion_ () Int) +(declare-fun System.Type () Int) +(declare-fun intLess (Int Int) Int) +(declare-fun AsImmutable_ (Int) Int) +(declare-fun NonNullFieldsAreInitialized_ () Int) +(declare-fun LBound_ (Int Int) Int) +(declare-fun System.Object () Int) +(declare-fun System.UInt32 () Int) +(declare-fun localinv_ () Int) +(declare-fun inv_ () Int) +(declare-fun OwnedResults.Static0_ (Int) Int) +(declare-fun entry_correct () Int) +(declare-fun OwnedResults.Pz_ (Int Int) Int) +(declare-fun FirstConsistentOwner_ () Int) +(declare-fun UnboxedType (Int) Int) +(declare-fun AsRefField (Int Int) Int) +(declare-fun System.Byte () Int) +(declare-fun AdditiveMethods () Int) +(declare-fun this () Int) +(declare-fun int_2147483647 () Int) +(declare-fun ArrayCategoryRef_ () Int) +(declare-fun Heap_ () Int) +(declare-fun OwnedResults.Qz_System.Int32_.1 (Int Int) Int) +(declare-fun Length_ (Int) Int) +(declare-fun AsNonNullRefField (Int Int) Int) +(declare-fun Sub () Int) +(declare-fun IsHeap (Int) Int) +(declare-fun OwnedResults.Static1_ (Int) Int) +(declare-fun UBound_ (Int Int) Int) +(declare-fun System.String () Int) +(declare-fun System.String.IsInterned_System.String_notnull_ (Int) Int) +(declare-fun UnknownRef_ () Int) +(declare-fun Rank_ (Int) Int) +(declare-fun RefArraySet (Int Int Int) Int) +(declare-fun ValueArraySet (Int Int Int) Int) +(declare-fun boolOr (Int Int) Int) +(declare-fun sharingMode_ () Int) +(declare-fun AdditiveMethods.amRep () Int) +(declare-fun subtypes (Int Int) Bool) +(declare-fun System.String.Equals_System.String_System.String_ (Int Int) Int) +(declare-fun anyNeq (Int Int) Int) +(declare-fun IsStaticField (Int) Int) +(declare-fun IsNotNull_ (Int Int) Int) +(declare-fun typeof_ (Int) Int) +(declare-fun OwnedResults () Int) +(declare-fun ArrayCategoryNonNullRef_ () Int) +(declare-fun RefArrayGet (Int Int) Int) +(declare-fun ValueArrayGet (Int Int) Int) +(declare-fun TypeObject (Int) Int) +(declare-fun and_ (Int Int) Int) +(declare-fun OwnedResults.x () Int) +(declare-fun BoxTester (Int Int) Int) +(declare-fun OwnedResults.y () Int) +(declare-fun OwnedResults.Static2_ () Int) +(declare-fun IsValueType_ (Int) Int) +(declare-fun AsRangeField (Int Int) Int) +(declare-fun AdditiveMethods.amPeer () Int) +(declare-fun System.SByte () Int) +(declare-fun BeingConstructed_ () Int) +(declare-fun FieldDependsOnFCO_ (Int Int Int) Int) +(declare-fun NonNullRefArray (Int Int) Int) +(declare-fun RefArray (Int Int) Int) +(declare-fun ArrayCategory_ (Int) Int) +(declare-fun return.value_0 () Int) +(declare-fun AsPureObject_ (Int) Int) +(declare-fun System.String.Equals_System.String_ (Int Int) Int) +(declare-fun System.Int16 () Int) +(declare-fun AsMutable_ (Int) Int) +(declare-fun OwnedResults.Pw_.1 (Int) Int) +(declare-fun System.Char () Int) +(declare-fun System.UInt64 () Int) +(declare-fun StructGet_ (Int Int) Int) +(declare-fun OneClassDown (Int Int) Int) +(declare-fun ArrayIndex (Int Int Int Int) Int) +(declare-fun Box (Int Int) Int) +(declare-fun int_18446744073709551615 () Int) +(declare-fun shr_ (Int Int) Int) +(declare-fun OwnedResults.Pz_.1 (Int) Int) +(declare-fun IsDirectlyModifiableField (Int) Int) +(declare-fun StringLength_ (Int) Int) +(declare-fun allocated_ () Int) +(declare-fun block8806_correct () Int) +(declare-fun BaseClass_ (Int) Int) +(declare-fun ValueArray (Int Int) Int) +(declare-fun Smt.false () Int) +(declare-fun IsImmutable_ (Int) Int) +(declare-fun elements_ () Int) +(declare-fun DeclType (Int) Int) +(declare-fun ReallyLastGeneratedExit_correct () Int) +(assert (distinct allocated_ elements_ inv_ localinv_ exposeVersion_ sharingMode_ SharingMode_Unshared_ SharingMode_LockProtected_ ownerRef_ ownerFrame_ PeerGroupPlaceholder_ ArrayCategoryValue_ ArrayCategoryRef_ ArrayCategoryNonNullRef_ System.Array System.Object System.Type BeingConstructed_ NonNullFieldsAreInitialized_ System.String FirstConsistentOwner_ System.SByte System.Byte System.Int16 System.UInt16 System.Int32 System.UInt32 System.Int64 System.UInt64 System.Char int_m2147483648 int_2147483647 int_4294967295 int_m9223372036854775808 int_9223372036854775807 int_18446744073709551615 UnknownRef_ OwnedResults.x AdditiveMethods.amPeer AdditiveMethods.amRep OwnedResults.y OwnedResults System.Runtime.InteropServices._Type System.Runtime.InteropServices._MemberInfo System.Reflection.IReflect Sub System.Reflection.ICustomAttributeProvider System.Boolean AdditiveMethods T System.Reflection.MemberInfo)) +(assert (= (DeclType exposeVersion_) System.Object)) +(assert (forall ((?c0 Int) (?c1 Int)) (! (=> (not (= ?c0 ?c1)) (not (= (ClassRepr ?c0) (ClassRepr ?c1)))) :pattern ((ClassRepr ?c0) (ClassRepr ?c1)) ))) +(assert (forall ((?T Int)) (not (subtypes (typeof_ (ClassRepr ?T)) System.Object)))) +(assert (forall ((?T Int)) (not (= (ClassRepr ?T) nullObject)))) +(assert (forall ((?T Int) (?h Int)) (! (=> (= (IsHeap ?h) Smt.true) (= (select2 ?h (ClassRepr ?T) ownerFrame_) PeerGroupPlaceholder_)) :pattern ((select2 ?h (ClassRepr ?T) ownerFrame_)) ))) +(assert (not (= (IsDirectlyModifiableField allocated_) Smt.true))) +(assert (= (IsDirectlyModifiableField elements_) Smt.true)) +(assert (not (= (IsDirectlyModifiableField inv_) Smt.true))) +(assert (not (= (IsDirectlyModifiableField localinv_) Smt.true))) +(assert (not (= (IsDirectlyModifiableField ownerRef_) Smt.true))) +(assert (not (= (IsDirectlyModifiableField ownerFrame_) Smt.true))) +(assert (not (= (IsDirectlyModifiableField exposeVersion_) Smt.true))) +(assert (not (= (IsStaticField allocated_) Smt.true))) +(assert (not (= (IsStaticField elements_) Smt.true))) +(assert (not (= (IsStaticField inv_) Smt.true))) +(assert (not (= (IsStaticField localinv_) Smt.true))) +(assert (not (= (IsStaticField exposeVersion_) Smt.true))) +(assert (forall ((?A Int) (?i Int) (?x Int)) (= (ValueArrayGet (ValueArraySet ?A ?i ?x) ?i) ?x))) +(assert (forall ((?A Int) (?i Int) (?j Int) (?x Int)) (=> (not (= ?i ?j)) (= (ValueArrayGet (ValueArraySet ?A ?i ?x) ?j) (ValueArrayGet ?A ?j))))) +(assert (forall ((?A Int) (?i Int) (?x Int)) (= (RefArrayGet (RefArraySet ?A ?i ?x) ?i) ?x))) +(assert (forall ((?A Int) (?i Int) (?j Int) (?x Int)) (=> (not (= ?i ?j)) (= (RefArrayGet (RefArraySet ?A ?i ?x) ?j) (RefArrayGet ?A ?j))))) +(assert (forall ((?a Int) (?d Int) (?x Int) (?y Int) (|?x'| Int) (|?y'| Int)) (! (=> (= (ArrayIndex ?a ?d ?x ?y) (ArrayIndex ?a ?d |?x'| |?y'|)) (and (= ?x |?x'|) (= ?y |?y'|))) :pattern ((ArrayIndex ?a ?d ?x ?y) (ArrayIndex ?a ?d |?x'| |?y'|)) ))) +(assert (forall ((?a Int) (?T Int) (?i Int) (?r Int) (?heap Int)) (! (=> (and (= (IsHeap ?heap) Smt.true) (subtypes (typeof_ ?a) (RefArray ?T ?r))) (= (Is_ (RefArrayGet (select2 ?heap ?a elements_) ?i) ?T) Smt.true)) :pattern ((subtypes (typeof_ ?a) (RefArray ?T ?r)) (RefArrayGet (select2 ?heap ?a elements_) ?i)) ))) +(assert (forall ((?a Int) (?T Int) (?i Int) (?r Int) (?heap Int)) (! (=> (and (= (IsHeap ?heap) Smt.true) (subtypes (typeof_ ?a) (NonNullRefArray ?T ?r))) (= (IsNotNull_ (RefArrayGet (select2 ?heap ?a elements_) ?i) ?T) Smt.true)) :pattern ((subtypes (typeof_ ?a) (NonNullRefArray ?T ?r)) (RefArrayGet (select2 ?heap ?a elements_) ?i)) ))) +(assert (forall ((?a Int)) (<= 1 (Rank_ ?a)))) +(assert (forall ((?a Int) (?T Int) (?r Int)) (! (=> (and (not (= ?a nullObject)) (subtypes (typeof_ ?a) (RefArray ?T ?r))) (= (Rank_ ?a) ?r)) :pattern ((subtypes (typeof_ ?a) (RefArray ?T ?r))) ))) +(assert (forall ((?a Int) (?T Int) (?r Int)) (! (=> (and (not (= ?a nullObject)) (subtypes (typeof_ ?a) (NonNullRefArray ?T ?r))) (= (Rank_ ?a) ?r)) :pattern ((subtypes (typeof_ ?a) (NonNullRefArray ?T ?r))) ))) +(assert (forall ((?a Int) (?T Int) (?r Int)) (! (=> (and (not (= ?a nullObject)) (subtypes (typeof_ ?a) (ValueArray ?T ?r))) (= (Rank_ ?a) ?r)) :pattern ((subtypes (typeof_ ?a) (ValueArray ?T ?r))) ))) +(assert (forall ((?a Int)) (! (<= 0 (Length_ ?a)) :pattern ((Length_ ?a)) ))) +(assert (forall ((?a Int) (?i Int)) (<= 0 (DimLength_ ?a ?i)))) +(assert (forall ((?a Int)) (! (=> (= (Rank_ ?a) 1) (= (DimLength_ ?a 0) (Length_ ?a))) :pattern ((DimLength_ ?a 0)) ))) +(assert (forall ((?a Int) (?i Int)) (! (= (LBound_ ?a ?i) 0) :pattern ((LBound_ ?a ?i)) ))) +(assert (forall ((?a Int) (?i Int)) (! (= (UBound_ ?a ?i) (- (DimLength_ ?a ?i) 1)) :pattern ((UBound_ ?a ?i)) ))) +(assert (forall ((?T Int) (?ET Int) (?r Int)) (! (=> (subtypes ?T (ValueArray ?ET ?r)) (= (ArrayCategory_ ?T) ArrayCategoryValue_)) :pattern ((subtypes ?T (ValueArray ?ET ?r))) ))) +(assert (forall ((?T Int) (?ET Int) (?r Int)) (! (=> (subtypes ?T (RefArray ?ET ?r)) (= (ArrayCategory_ ?T) ArrayCategoryRef_)) :pattern ((subtypes ?T (RefArray ?ET ?r))) ))) +(assert (forall ((?T Int) (?ET Int) (?r Int)) (! (=> (subtypes ?T (NonNullRefArray ?ET ?r)) (= (ArrayCategory_ ?T) ArrayCategoryNonNullRef_)) :pattern ((subtypes ?T (NonNullRefArray ?ET ?r))) ))) +(assert (subtypes System.Array System.Object)) +(assert (forall ((?T Int) (?r Int)) (! (subtypes (ValueArray ?T ?r) System.Array) :pattern ((ValueArray ?T ?r)) ))) +(assert (forall ((?T Int) (?r Int)) (! (subtypes (RefArray ?T ?r) System.Array) :pattern ((RefArray ?T ?r)) ))) +(assert (forall ((?T Int) (?r Int)) (! (subtypes (NonNullRefArray ?T ?r) System.Array) :pattern ((NonNullRefArray ?T ?r)) ))) +(assert (forall ((?T Int) (?U Int) (?r Int)) (=> (subtypes ?U ?T) (subtypes (RefArray ?U ?r) (RefArray ?T ?r))))) +(assert (forall ((?T Int) (?U Int) (?r Int)) (=> (subtypes ?U ?T) (subtypes (NonNullRefArray ?U ?r) (NonNullRefArray ?T ?r))))) +(assert (forall ((?A Int) (?r Int)) (= (ElementType_ (ValueArray ?A ?r)) ?A))) +(assert (forall ((?A Int) (?r Int)) (= (ElementType_ (RefArray ?A ?r)) ?A))) +(assert (forall ((?A Int) (?r Int)) (= (ElementType_ (NonNullRefArray ?A ?r)) ?A))) +(assert (forall ((?A Int) (?r Int) (?T Int)) (! (let ((?v_0 (ElementType_ ?T))) (=> (subtypes ?T (RefArray ?A ?r)) (and (= ?T (RefArray ?v_0 ?r)) (subtypes ?v_0 ?A)))) :pattern ((subtypes ?T (RefArray ?A ?r))) ))) +(assert (forall ((?A Int) (?r Int) (?T Int)) (! (let ((?v_0 (ElementType_ ?T))) (=> (subtypes ?T (NonNullRefArray ?A ?r)) (and (= ?T (NonNullRefArray ?v_0 ?r)) (subtypes ?v_0 ?A)))) :pattern ((subtypes ?T (NonNullRefArray ?A ?r))) ))) +(assert (forall ((?A Int) (?r Int) (?T Int)) (let ((?v_0 (ValueArray ?A ?r))) (=> (subtypes ?T ?v_0) (= ?T ?v_0))))) +(assert (forall ((?A Int) (?r Int) (?T Int)) (let ((?v_0 (ElementType_ ?T))) (=> (subtypes (RefArray ?A ?r) ?T) (or (subtypes System.Array ?T) (and (= ?T (RefArray ?v_0 ?r)) (subtypes ?A ?v_0))))))) +(assert (forall ((?A Int) (?r Int) (?T Int)) (let ((?v_0 (ElementType_ ?T))) (=> (subtypes (NonNullRefArray ?A ?r) ?T) (or (subtypes System.Array ?T) (and (= ?T (NonNullRefArray ?v_0 ?r)) (subtypes ?A ?v_0))))))) +(assert (forall ((?A Int) (?r Int) (?T Int)) (let ((?v_0 (ValueArray ?A ?r))) (=> (subtypes ?v_0 ?T) (or (subtypes System.Array ?T) (= ?T ?v_0)))))) +(assert (forall ((?s Int) (?f Int) (?x Int)) (= (StructGet_ (StructSet_ ?s ?f ?x) ?f) ?x))) +(assert (forall ((?s Int) (?f Int) (|?f'| Int) (?x Int)) (=> (not (= ?f |?f'|)) (= (StructGet_ (StructSet_ ?s ?f ?x) |?f'|) (StructGet_ ?s |?f'|))))) +(assert (forall ((?A Int) (?B Int) (?C Int)) (! (=> (subtypes ?C (AsDirectSubClass ?B ?A)) (= (OneClassDown ?C ?A) ?B)) :pattern ((subtypes ?C (AsDirectSubClass ?B ?A))) ))) +(assert (forall ((?T Int)) (=> (= (IsValueType_ ?T) Smt.true) (and (forall ((?U Int)) (=> (subtypes ?T ?U) (= ?T ?U))) (forall ((?U Int)) (=> (subtypes ?U ?T) (= ?T ?U))))))) +(assert (subtypes System.Type System.Object)) +(assert (forall ((?T Int)) (! (= (IsNotNull_ (TypeObject ?T) System.Type) Smt.true) :pattern ((TypeObject ?T)) ))) +(assert (forall ((?T Int)) (! (= (TypeName (TypeObject ?T)) ?T) :pattern ((TypeObject ?T)) ))) +(assert (forall ((?o Int) (?T Int)) (! (= (= (Is_ ?o ?T) Smt.true) (or (= ?o nullObject) (subtypes (typeof_ ?o) ?T))) :pattern ((Is_ ?o ?T)) ))) +(assert (forall ((?o Int) (?T Int)) (! (= (= (IsNotNull_ ?o ?T) Smt.true) (and (not (= ?o nullObject)) (= (Is_ ?o ?T) Smt.true))) :pattern ((IsNotNull_ ?o ?T)) ))) +(assert (forall ((?o Int) (?T Int)) (=> (= (Is_ ?o ?T) Smt.true) (= (As_ ?o ?T) ?o)))) +(assert (forall ((?o Int) (?T Int)) (=> (not (= (Is_ ?o ?T) Smt.true)) (= (As_ ?o ?T) nullObject)))) +(assert (forall ((?h Int) (?o Int)) (! (let ((?v_0 (typeof_ ?o))) (=> (and (= (IsHeap ?h) Smt.true) (not (= ?o nullObject)) (subtypes ?v_0 System.Array)) (and (= (select2 ?h ?o inv_) ?v_0) (= (select2 ?h ?o localinv_) ?v_0)))) :pattern ((select2 ?h ?o inv_)) ))) +(assert (forall ((?h Int) (?o Int) (?f Int)) (! (=> (and (= (IsHeap ?h) Smt.true) (= (select2 ?h ?o allocated_) Smt.true)) (= (IsAllocated ?h (select2 ?h ?o ?f)) Smt.true)) :pattern ((IsAllocated ?h (select2 ?h ?o ?f))) ))) +(assert (forall ((?h Int) (?o Int) (?f Int)) (! (=> (and (= (IsHeap ?h) Smt.true) (= (select2 ?h ?o allocated_) Smt.true)) (= (select2 ?h (select2 ?h ?o ?f) allocated_) Smt.true)) :pattern ((select2 ?h (select2 ?h ?o ?f) allocated_)) ))) +(assert (forall ((?h Int) (?s Int) (?f Int)) (! (=> (= (IsAllocated ?h ?s) Smt.true) (= (IsAllocated ?h (StructGet_ ?s ?f)) Smt.true)) :pattern ((IsAllocated ?h (StructGet_ ?s ?f))) ))) +(assert (forall ((?h Int) (?e Int) (?i Int)) (! (=> (= (IsAllocated ?h ?e) Smt.true) (= (IsAllocated ?h (RefArrayGet ?e ?i)) Smt.true)) :pattern ((IsAllocated ?h (RefArrayGet ?e ?i))) ))) +(assert (forall ((?h Int) (?e Int) (?i Int)) (! (=> (= (IsAllocated ?h ?e) Smt.true) (= (IsAllocated ?h (ValueArrayGet ?e ?i)) Smt.true)) :pattern ((IsAllocated ?h (ValueArrayGet ?e ?i))) ))) +(assert (forall ((?h Int) (?o Int)) (! (=> (= (IsAllocated ?h ?o) Smt.true) (= (select2 ?h ?o allocated_) Smt.true)) :pattern ((select2 ?h ?o allocated_)) ))) +(assert (forall ((?h Int) (?c Int)) (! (=> (= (IsHeap ?h) Smt.true) (= (select2 ?h (ClassRepr ?c) allocated_) Smt.true)) :pattern ((select2 ?h (ClassRepr ?c) allocated_)) ))) +(assert (forall ((?f Int) (?T Int)) (! (=> (= (AsNonNullRefField ?f ?T) ?f) (= (AsRefField ?f ?T) ?f)) :pattern ((AsNonNullRefField ?f ?T)) ))) +(assert (forall ((?h Int) (?o Int) (?f Int) (?T Int)) (! (=> (= (IsHeap ?h) Smt.true) (= (Is_ (select2 ?h ?o (AsRefField ?f ?T)) ?T) Smt.true)) :pattern ((select2 ?h ?o (AsRefField ?f ?T))) ))) +(assert (forall ((?h Int) (?o Int) (?f Int) (?T Int)) (! (=> (and (= (IsHeap ?h) Smt.true) (not (= ?o nullObject)) (or (not (= ?o BeingConstructed_)) (= (= (select2 ?h BeingConstructed_ NonNullFieldsAreInitialized_) Smt.true) true))) (not (= (select2 ?h ?o (AsNonNullRefField ?f ?T)) nullObject))) :pattern ((select2 ?h ?o (AsNonNullRefField ?f ?T))) ))) +(assert (forall ((?h Int) (?o Int) (?f Int) (?T Int)) (! (=> (= (IsHeap ?h) Smt.true) (InRange (select2 ?h ?o (AsRangeField ?f ?T)) ?T)) :pattern ((select2 ?h ?o (AsRangeField ?f ?T))) ))) +(assert (forall ((?o Int)) (! (not (= (IsMemberlessType_ (typeof_ ?o)) Smt.true)) :pattern ((IsMemberlessType_ (typeof_ ?o))) ))) +(assert (not (= (IsImmutable_ System.Object) Smt.true))) +(assert (forall ((?T Int) (?U Int)) (! (=> (subtypes ?U (AsImmutable_ ?T)) (and (= (IsImmutable_ ?U) Smt.true) (= (AsImmutable_ ?U) ?U))) :pattern ((subtypes ?U (AsImmutable_ ?T))) ))) +(assert (forall ((?T Int) (?U Int)) (! (=> (subtypes ?U (AsMutable_ ?T)) (and (not (= (IsImmutable_ ?U) Smt.true)) (= (AsMutable_ ?U) ?U))) :pattern ((subtypes ?U (AsMutable_ ?T))) ))) +(assert (forall ((?o Int) (?T Int)) (! (=> (and (not (= ?o nullObject)) (not (= ?o BeingConstructed_)) (subtypes (typeof_ ?o) (AsImmutable_ ?T))) (forall ((?h Int)) (! (let ((?v_0 (typeof_ ?o))) (=> (= (IsHeap ?h) Smt.true) (and (= (select2 ?h ?o inv_) ?v_0) (= (select2 ?h ?o localinv_) ?v_0) (= (select2 ?h ?o ownerFrame_) PeerGroupPlaceholder_) (= (AsOwner ?o (select2 ?h ?o ownerRef_)) ?o) (forall ((?t Int)) (! (=> (= (AsOwner ?o (select2 ?h ?t ownerRef_)) ?o) (or (= ?t ?o) (not (= (select2 ?h ?t ownerFrame_) PeerGroupPlaceholder_)))) :pattern ((AsOwner ?o (select2 ?h ?t ownerRef_))) ))))) :pattern ((IsHeap ?h)) ))) :pattern ((subtypes (typeof_ ?o) (AsImmutable_ ?T))) ))) +(assert (forall ((?s Int)) (! (<= 0 (StringLength_ ?s)) :pattern ((StringLength_ ?s)) ))) +(assert (forall ((?h Int) (?o Int) (?f Int) (?T Int)) (! (let ((?v_0 (select2 ?h ?o (AsRepField ?f ?T)))) (=> (and (= (IsHeap ?h) Smt.true) (not (= ?v_0 nullObject))) (and (= (select2 ?h ?v_0 ownerRef_) ?o) (= (select2 ?h ?v_0 ownerFrame_) ?T)))) :pattern ((select2 ?h ?o (AsRepField ?f ?T))) ))) +(assert (forall ((?h Int) (?o Int) (?f Int)) (! (let ((?v_0 (select2 ?h ?o (AsPeerField ?f)))) (=> (and (= (IsHeap ?h) Smt.true) (not (= ?v_0 nullObject))) (and (= (select2 ?h ?v_0 ownerRef_) (select2 ?h ?o ownerRef_)) (= (select2 ?h ?v_0 ownerFrame_) (select2 ?h ?o ownerFrame_))))) :pattern ((select2 ?h ?o (AsPeerField ?f))) ))) +(assert (forall ((?h Int) (?o Int)) (let ((?v_0 (select2 ?h ?o ownerFrame_)) (?v_1 (select2 ?h ?o ownerRef_)) (?v_2 (typeof_ ?o))) (=> (and (= (IsHeap ?h) Smt.true) (not (= ?v_0 PeerGroupPlaceholder_)) (subtypes (select2 ?h ?v_1 inv_) ?v_0) (not (= (select2 ?h ?v_1 localinv_) (BaseClass_ ?v_0)))) (and (= (select2 ?h ?o inv_) ?v_2) (= (select2 ?h ?o localinv_) ?v_2)))))) +(assert (forall ((?o Int) (?f Int) (?h Int)) (! (let ((?v_0 (select2 ?h ?o ownerFrame_)) (?v_1 (select2 ?h ?o ownerRef_))) (=> (and (= (IsHeap ?h) Smt.true) (not (= ?o nullObject)) (= (= (select2 ?h ?o allocated_) Smt.true) true) (not (= ?v_0 PeerGroupPlaceholder_)) (subtypes (select2 ?h ?v_1 inv_) ?v_0) (not (= (select2 ?h ?v_1 localinv_) (BaseClass_ ?v_0)))) (= (select2 ?h ?o ?f) (FieldDependsOnFCO_ ?o ?f (select2 ?h (select2 ?h ?o FirstConsistentOwner_) exposeVersion_))))) :pattern ((select2 ?h (AsPureObject_ ?o) ?f)) ))) +(assert (forall ((?o Int) (?h Int)) (! (let ((?v_0 (select2 ?h ?o ownerFrame_)) (?v_1 (select2 ?h ?o ownerRef_)) (?v_2 (select2 ?h ?o FirstConsistentOwner_))) (let ((?v_3 (select2 ?h ?v_2 ownerFrame_)) (?v_4 (select2 ?h ?v_2 ownerRef_))) (=> (and (= (IsHeap ?h) Smt.true) (not (= ?o nullObject)) (= (= (select2 ?h ?o allocated_) Smt.true) true) (not (= ?v_0 PeerGroupPlaceholder_)) (subtypes (select2 ?h ?v_1 inv_) ?v_0) (not (= (select2 ?h ?v_1 localinv_) (BaseClass_ ?v_0)))) (and (not (= ?v_2 nullObject)) (= (= (select2 ?h ?v_2 allocated_) Smt.true) true) (or (= ?v_3 PeerGroupPlaceholder_) (not (subtypes (select2 ?h ?v_4 inv_) ?v_3)) (= (select2 ?h ?v_4 localinv_) (BaseClass_ ?v_3))))))) :pattern ((select2 ?h ?o FirstConsistentOwner_)) ))) +(assert (forall ((?x Int) (?p Int)) (! (= (Unbox (Box ?x ?p)) ?x) :pattern ((Unbox (Box ?x ?p))) ))) +(assert (forall ((?p Int)) (! (=> (= (IsValueType_ (UnboxedType ?p)) Smt.true) (forall ((?heap Int) (?x Int)) (let ((?v_0 (Box ?x ?p))) (let ((?v_1 (typeof_ ?v_0))) (=> (= (IsHeap ?heap) Smt.true) (and (= (select2 ?heap ?v_0 inv_) ?v_1) (= (select2 ?heap ?v_0 localinv_) ?v_1))))))) :pattern ((IsValueType_ (UnboxedType ?p))) ))) +(assert (forall ((?x Int) (?p Int)) (let ((?v_0 (Box ?x ?p))) (=> (and (subtypes (UnboxedType ?v_0) System.Object) (= ?v_0 ?p)) (= ?x ?p))))) +(assert (forall ((?p Int) (?typ Int)) (! (= (= (UnboxedType ?p) ?typ) (not (= (BoxTester ?p ?typ) nullObject))) :pattern ((BoxTester ?p ?typ)) ))) +(assert (= (IsValueType_ System.SByte) Smt.true)) +(assert (= (IsValueType_ System.Byte) Smt.true)) +(assert (= (IsValueType_ System.Int16) Smt.true)) +(assert (= (IsValueType_ System.UInt16) Smt.true)) +(assert (= (IsValueType_ System.Int32) Smt.true)) +(assert (= (IsValueType_ System.UInt32) Smt.true)) +(assert (= (IsValueType_ System.Int64) Smt.true)) +(assert (= (IsValueType_ System.UInt64) Smt.true)) +(assert (= (IsValueType_ System.Char) Smt.true)) +(assert (< int_m9223372036854775808 int_m2147483648)) +(assert (< int_m2147483648 (- 0 100000))) +(assert (< 100000 int_2147483647)) +(assert (< int_2147483647 int_4294967295)) +(assert (< int_4294967295 int_9223372036854775807)) +(assert (< int_9223372036854775807 int_18446744073709551615)) +(assert (forall ((?i Int)) (= (InRange ?i System.SByte) (and (<= (- 0 128) ?i) (< ?i 128))))) +(assert (forall ((?i Int)) (= (InRange ?i System.Byte) (and (<= 0 ?i) (< ?i 256))))) +(assert (forall ((?i Int)) (= (InRange ?i System.Int16) (and (<= (- 0 32768) ?i) (< ?i 32768))))) +(assert (forall ((?i Int)) (= (InRange ?i System.UInt16) (and (<= 0 ?i) (< ?i 65536))))) +(assert (forall ((?i Int)) (= (InRange ?i System.Int32) (and (<= int_m2147483648 ?i) (<= ?i int_2147483647))))) +(assert (forall ((?i Int)) (= (InRange ?i System.UInt32) (and (<= 0 ?i) (<= ?i int_4294967295))))) +(assert (forall ((?i Int)) (= (InRange ?i System.Int64) (and (<= int_m9223372036854775808 ?i) (<= ?i int_9223372036854775807))))) +(assert (forall ((?i Int)) (= (InRange ?i System.UInt64) (and (<= 0 ?i) (<= ?i int_18446744073709551615))))) +(assert (forall ((?i Int)) (= (InRange ?i System.Char) (and (<= 0 ?i) (< ?i 65536))))) +(assert (forall ((?b Int) (?x Int) (?y Int)) (! (=> (= ?b Smt.true) (= (IfThenElse_ ?b ?x ?y) ?x)) :pattern ((IfThenElse_ ?b ?x ?y)) ))) +(assert (forall ((?b Int) (?x Int) (?y Int)) (! (=> (not (= ?b Smt.true)) (= (IfThenElse_ ?b ?x ?y) ?y)) :pattern ((IfThenElse_ ?b ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (modulo ?x ?y) (- ?x (multiply (divide ?x ?y) ?y))) :pattern ((modulo ?x ?y)) :pattern ((divide ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (modulo ?x ?y))) (=> (and (<= 0 ?x) (< 0 ?y)) (and (<= 0 ?v_0) (< ?v_0 ?y)))) :pattern ((modulo ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (modulo ?x ?y))) (=> (and (<= 0 ?x) (< ?y 0)) (and (<= 0 ?v_0) (< ?v_0 (- 0 ?y))))) :pattern ((modulo ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (modulo ?x ?y))) (=> (and (<= ?x 0) (< 0 ?y)) (and (< (- 0 ?y) ?v_0) (<= ?v_0 0)))) :pattern ((modulo ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (modulo ?x ?y))) (=> (and (<= ?x 0) (< ?y 0)) (and (< ?y ?v_0) (<= ?v_0 0)))) :pattern ((modulo ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (=> (and (<= 0 ?x) (<= 0 ?y)) (= (modulo (+ ?x ?y) ?y) (modulo ?x ?y))))) +(assert (forall ((?x Int) (?y Int)) (=> (and (<= 0 ?x) (<= 0 ?y)) (= (modulo (+ ?y ?x) ?y) (modulo ?x ?y))))) +(assert (forall ((?x Int) (?y Int)) (let ((?v_0 (- ?x ?y))) (=> (and (<= 0 ?v_0) (<= 0 ?y)) (= (modulo ?v_0 ?y) (modulo ?x ?y)))))) +(assert (forall ((?a Int) (?b Int) (?d Int)) (! (=> (and (<= 2 ?d) (= (modulo ?a ?d) (modulo ?b ?d)) (< ?a ?b)) (<= (+ ?a ?d) ?b)) :pattern ((modulo ?a ?d) (modulo ?b ?d)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (or (<= 0 ?x) (<= 0 ?y)) (<= 0 (and_ ?x ?y))) :pattern ((and_ ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (or_ ?x ?y))) (=> (and (<= 0 ?x) (<= 0 ?y)) (and (<= 0 ?v_0) (<= ?v_0 (+ ?x ?y))))) :pattern ((or_ ?x ?y)) ))) +(assert (forall ((?i Int)) (! (= (shl_ ?i 0) ?i) :pattern ((shl_ ?i 0)) ))) +(assert (forall ((?i Int) (?j Int)) (=> (<= 0 ?j) (= (shl_ ?i (+ ?j 1)) (* (shl_ ?i ?j) 2))))) +(assert (forall ((?i Int)) (! (= (shr_ ?i 0) ?i) :pattern ((shr_ ?i 0)) ))) +(assert (forall ((?i Int) (?j Int)) (=> (<= 0 ?j) (= (shr_ ?i (+ ?j 1)) (divide (shr_ ?i ?j) 2))))) +(assert (forall ((?a Int) (?b Int)) (! (= (= (System.String.Equals_System.String_ ?a ?b) Smt.true) (= (System.String.Equals_System.String_System.String_ ?a ?b) Smt.true)) :pattern ((System.String.Equals_System.String_ ?a ?b)) ))) +(assert (forall ((?a Int) (?b Int)) (! (= (= (System.String.Equals_System.String_System.String_ ?a ?b) Smt.true) (= (System.String.Equals_System.String_System.String_ ?b ?a) Smt.true)) :pattern ((System.String.Equals_System.String_System.String_ ?a ?b)) ))) +(assert (forall ((?a Int) (?b Int)) (! (=> (and (not (= ?a nullObject)) (not (= ?b nullObject)) (= (System.String.Equals_System.String_System.String_ ?a ?b) Smt.true)) (= (System.String.IsInterned_System.String_notnull_ ?a) (System.String.IsInterned_System.String_notnull_ ?b))) :pattern ((System.String.Equals_System.String_System.String_ ?a ?b)) ))) +(assert (not (= (IsStaticField AdditiveMethods.amPeer) Smt.true))) +(assert (= (IsDirectlyModifiableField AdditiveMethods.amPeer) Smt.true)) +(assert (= (AsPeerField AdditiveMethods.amPeer) AdditiveMethods.amPeer)) +(assert (= (DeclType AdditiveMethods.amPeer) AdditiveMethods)) +(assert (= (AsRefField AdditiveMethods.amPeer AdditiveMethods) AdditiveMethods.amPeer)) +(assert (not (= (IsStaticField AdditiveMethods.amRep) Smt.true))) +(assert (= (IsDirectlyModifiableField AdditiveMethods.amRep) Smt.true)) +(assert (= (AsRepField AdditiveMethods.amRep AdditiveMethods) AdditiveMethods.amRep)) +(assert (= (DeclType AdditiveMethods.amRep) AdditiveMethods)) +(assert (= (AsRefField AdditiveMethods.amRep AdditiveMethods) AdditiveMethods.amRep)) +(assert (not (= (IsStaticField OwnedResults.x) Smt.true))) +(assert (= (IsDirectlyModifiableField OwnedResults.x) Smt.true)) +(assert (= (AsRepField OwnedResults.x OwnedResults) OwnedResults.x)) +(assert (= (DeclType OwnedResults.x) OwnedResults)) +(assert (= (AsRefField OwnedResults.x T) OwnedResults.x)) +(assert (not (= (IsStaticField OwnedResults.y) Smt.true))) +(assert (= (IsDirectlyModifiableField OwnedResults.y) Smt.true)) +(assert (= (AsPeerField OwnedResults.y) OwnedResults.y)) +(assert (= (DeclType OwnedResults.y) OwnedResults)) +(assert (= (AsRefField OwnedResults.y T) OwnedResults.y)) +(assert (subtypes AdditiveMethods AdditiveMethods)) +(assert (= (BaseClass_ AdditiveMethods) System.Object)) +(assert (subtypes AdditiveMethods (BaseClass_ AdditiveMethods))) +(assert (= (AsDirectSubClass AdditiveMethods (BaseClass_ AdditiveMethods)) AdditiveMethods)) +(assert (not (= (IsImmutable_ AdditiveMethods) Smt.true))) +(assert (= (AsMutable_ AdditiveMethods) AdditiveMethods)) +(assert (subtypes System.Type System.Type)) +(assert (subtypes System.Reflection.MemberInfo System.Reflection.MemberInfo)) +(assert (= (BaseClass_ System.Reflection.MemberInfo) System.Object)) +(assert (subtypes System.Reflection.MemberInfo (BaseClass_ System.Reflection.MemberInfo))) +(assert (= (AsDirectSubClass System.Reflection.MemberInfo (BaseClass_ System.Reflection.MemberInfo)) System.Reflection.MemberInfo)) +(assert (= (IsImmutable_ System.Reflection.MemberInfo) Smt.true)) +(assert (= (AsImmutable_ System.Reflection.MemberInfo) System.Reflection.MemberInfo)) +(assert (subtypes System.Reflection.ICustomAttributeProvider System.Object)) +(assert (= (IsMemberlessType_ System.Reflection.ICustomAttributeProvider) Smt.true)) +(assert (subtypes System.Reflection.MemberInfo System.Reflection.ICustomAttributeProvider)) +(assert (subtypes System.Runtime.InteropServices._MemberInfo System.Object)) +(assert (= (IsMemberlessType_ System.Runtime.InteropServices._MemberInfo) Smt.true)) +(assert (subtypes System.Reflection.MemberInfo System.Runtime.InteropServices._MemberInfo)) +(assert (= (IsMemberlessType_ System.Reflection.MemberInfo) Smt.true)) +(assert (= (BaseClass_ System.Type) System.Reflection.MemberInfo)) +(assert (subtypes System.Type (BaseClass_ System.Type))) +(assert (= (AsDirectSubClass System.Type (BaseClass_ System.Type)) System.Type)) +(assert (= (IsImmutable_ System.Type) Smt.true)) +(assert (= (AsImmutable_ System.Type) System.Type)) +(assert (subtypes System.Runtime.InteropServices._Type System.Object)) +(assert (= (IsMemberlessType_ System.Runtime.InteropServices._Type) Smt.true)) +(assert (subtypes System.Type System.Runtime.InteropServices._Type)) +(assert (subtypes System.Reflection.IReflect System.Object)) +(assert (= (IsMemberlessType_ System.Reflection.IReflect) Smt.true)) +(assert (subtypes System.Type System.Reflection.IReflect)) +(assert (= (IsMemberlessType_ System.Type) Smt.true)) +(assert (subtypes Sub Sub)) +(assert (= (BaseClass_ Sub) AdditiveMethods)) +(assert (subtypes Sub (BaseClass_ Sub))) +(assert (= (AsDirectSubClass Sub (BaseClass_ Sub)) Sub)) +(assert (not (= (IsImmutable_ Sub) Smt.true))) +(assert (= (AsMutable_ Sub) Sub)) +(assert (subtypes OwnedResults OwnedResults)) +(assert (= (BaseClass_ OwnedResults) System.Object)) +(assert (subtypes OwnedResults (BaseClass_ OwnedResults))) +(assert (= (AsDirectSubClass OwnedResults (BaseClass_ OwnedResults)) OwnedResults)) +(assert (not (= (IsImmutable_ OwnedResults) Smt.true))) +(assert (= (AsMutable_ OwnedResults) OwnedResults)) +(assert (subtypes T T)) +(assert (= (BaseClass_ T) System.Object)) +(assert (subtypes T (BaseClass_ T))) +(assert (= (AsDirectSubClass T (BaseClass_ T)) T)) +(assert (not (= (IsImmutable_ T) Smt.true))) +(assert (= (AsMutable_ T) T)) +(assert (forall ((?Heap_ Int) (?this Int)) (! (let ((?v_0 (OwnedResults.Mz_ ?Heap_ ?this))) (=> (and (= (IsHeap ?Heap_) Smt.true) (forall ((?pc_ Int)) (let ((?v_1 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?this ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?this ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_1) (= (select2 ?Heap_ ?pc_ localinv_) ?v_1)))))) (and (= (= (select2 ?Heap_ ?v_0 allocated_) Smt.true) true) (= (Is_ ?v_0 T) Smt.true) (or (= ?v_0 nullObject) (forall ((?pc_ Int)) (let ((?v_2 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?v_0 ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?v_0 ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_2) (= (select2 ?Heap_ ?pc_ localinv_) ?v_2)))))) (= ?v_0 (select2 ?Heap_ ?this OwnedResults.x))))) :pattern ((OwnedResults.Mz_ ?Heap_ ?this)) ))) +(assert (forall ((?Heap_ Int) (?this Int)) (! (let ((?v_0 (OwnedResults.Pz_ ?Heap_ ?this))) (=> (and (= (IsHeap ?Heap_) Smt.true) (forall ((?pc_ Int)) (let ((?v_1 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?this ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?this ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_1) (= (select2 ?Heap_ ?pc_ localinv_) ?v_1)))))) (and (= (= (select2 ?Heap_ ?v_0 allocated_) Smt.true) true) (= (Is_ ?v_0 T) Smt.true) (or (= ?v_0 nullObject) (forall ((?pc_ Int)) (let ((?v_2 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?v_0 ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?v_0 ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_2) (= (select2 ?Heap_ ?pc_ localinv_) ?v_2)))))) (= ?v_0 (select2 ?Heap_ ?this OwnedResults.x))))) :pattern ((OwnedResults.Pz_ ?Heap_ ?this)) ))) +(assert (forall ((?Heap_ Int) (?this Int)) (! (let ((?v_0 (typeof_ ?this))) (=> (and (not (= ?this nullObject)) (subtypes ?v_0 OwnedResults) (= (select2 ?Heap_ ?this inv_) ?v_0) (= (select2 ?Heap_ ?this localinv_) ?v_0) (= (IsHeap ?Heap_) Smt.true) (= (= (select2 ?Heap_ ?this allocated_) Smt.true) true)) (= (OwnedResults.Pz_ ?Heap_ ?this) (OwnedResults.Pz_.1 (select2 ?Heap_ ?this exposeVersion_))))) :pattern ((OwnedResults.Pz_ ?Heap_ ?this)) ))) +(assert (forall ((?Heap_ Int) (?this Int)) (! (let ((?v_0 (OwnedResults.Pw_ ?Heap_ ?this))) (=> (and (= (IsHeap ?Heap_) Smt.true) (forall ((?pc_ Int)) (let ((?v_1 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?this ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?this ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_1) (= (select2 ?Heap_ ?pc_ localinv_) ?v_1)))))) (and (= (= (select2 ?Heap_ ?v_0 allocated_) Smt.true) true) (= (Is_ ?v_0 T) Smt.true) (or (= ?v_0 nullObject) (forall ((?pc_ Int)) (let ((?v_2 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?v_0 ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?v_0 ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_2) (= (select2 ?Heap_ ?pc_ localinv_) ?v_2)))))) (= ?v_0 (select2 ?Heap_ ?this OwnedResults.y))))) :pattern ((OwnedResults.Pw_ ?Heap_ ?this)) ))) +(assert (forall ((?Heap_ Int) (?this Int)) (! (let ((?v_0 (typeof_ ?this))) (=> (and (not (= ?this nullObject)) (subtypes ?v_0 OwnedResults) (= (select2 ?Heap_ ?this inv_) ?v_0) (= (select2 ?Heap_ ?this localinv_) ?v_0) (= (IsHeap ?Heap_) Smt.true) (= (= (select2 ?Heap_ ?this allocated_) Smt.true) true)) (= (OwnedResults.Pw_ ?Heap_ ?this) (OwnedResults.Pw_.1 (select2 ?Heap_ ?this exposeVersion_))))) :pattern ((OwnedResults.Pw_ ?Heap_ ?this)) ))) +(assert (forall ((?Heap_ Int) (?this Int) (?k_in Int)) (! (let ((?v_0 (OwnedResults.Qz_System.Int32_ ?Heap_ ?this ?k_in))) (=> (and (= (IsHeap ?Heap_) Smt.true) (InRange ?k_in System.Int32) (forall ((?pc_ Int)) (let ((?v_1 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?this ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?this ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_1) (= (select2 ?Heap_ ?pc_ localinv_) ?v_1)))))) (and (= (= (select2 ?Heap_ ?v_0 allocated_) Smt.true) true) (= (Is_ ?v_0 T) Smt.true) (or (= ?v_0 nullObject) (forall ((?pc_ Int)) (let ((?v_2 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?v_0 ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?v_0 ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_2) (= (select2 ?Heap_ ?pc_ localinv_) ?v_2))))))))) :pattern ((OwnedResults.Qz_System.Int32_ ?Heap_ ?this ?k_in)) ))) +(assert (forall ((?Heap_ Int) (?this Int) (?k_in Int)) (! (let ((?v_0 (typeof_ ?this))) (=> (and (not (= ?this nullObject)) (subtypes ?v_0 OwnedResults) (= (select2 ?Heap_ ?this inv_) ?v_0) (= (select2 ?Heap_ ?this localinv_) ?v_0) (= (IsHeap ?Heap_) Smt.true) (= (= (select2 ?Heap_ ?this allocated_) Smt.true) true)) (= (OwnedResults.Qz_System.Int32_ ?Heap_ ?this ?k_in) (OwnedResults.Qz_System.Int32_.1 (select2 ?Heap_ ?this exposeVersion_) ?k_in)))) :pattern ((OwnedResults.Qz_System.Int32_ ?Heap_ ?this ?k_in)) ))) +(assert (forall ((?U_ Int)) (! (=> (subtypes ?U_ System.Boolean) (= ?U_ System.Boolean)) :pattern ((subtypes ?U_ System.Boolean)) ))) +(assert (forall ((?Heap_ Int)) (! (let ((?v_0 (OwnedResults.Static0_ ?Heap_))) (=> (= (IsHeap ?Heap_) Smt.true) (and (= (= (select2 ?Heap_ ?v_0 allocated_) Smt.true) true) (= (IsNotNull_ ?v_0 T) Smt.true) (forall ((?pc_ Int)) (let ((?v_1 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?v_0 ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?v_0 ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_1) (= (select2 ?Heap_ ?pc_ localinv_) ?v_1)))))))) :pattern ((OwnedResults.Static0_ ?Heap_)) ))) +(assert (forall ((?Heap_ Int)) (! (let ((?v_0 (OwnedResults.Static1_ ?Heap_))) (=> (= (IsHeap ?Heap_) Smt.true) (and (= (= (select2 ?Heap_ ?v_0 allocated_) Smt.true) true) (= (IsNotNull_ ?v_0 T) Smt.true) (forall ((?pc_ Int)) (let ((?v_1 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 ?Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 ?Heap_ ?pc_ ownerRef_) (select2 ?Heap_ ?v_0 ownerRef_)) (= (select2 ?Heap_ ?pc_ ownerFrame_) (select2 ?Heap_ ?v_0 ownerFrame_))) (and (= (select2 ?Heap_ ?pc_ inv_) ?v_1) (= (select2 ?Heap_ ?pc_ localinv_) ?v_1)))))))) :pattern ((OwnedResults.Static1_ ?Heap_)) ))) +(assert (=> true (= (IsNotNull_ OwnedResults.Static2_ T) Smt.true))) +(assert (forall ((?A Int) (?i Int) (?v Int)) (= (select1 (store1 ?A ?i ?v) ?i) ?v))) +(assert (forall ((?A Int) (?i Int) (?j Int) (?v Int)) (=> (not (= ?i ?j)) (= (select1 (store1 ?A ?i ?v) ?j) (select1 ?A ?j))))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?v Int)) (= (select2 (store2 ?A ?o ?f ?v) ?o ?f) ?v))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?o ?p)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?f ?g)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolIff ?x ?y) Smt.true) (= (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolImplies ?x ?y) Smt.true) (=> (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolAnd ?x ?y) Smt.true) (and (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolOr ?x ?y) Smt.true) (or (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int)) (! (= (= (boolNot ?x) Smt.true) (not (= ?x Smt.true))) :pattern ((boolNot ?x)) ))) +(assert (forall ((?x Int) (?y Int)) (= (= (anyEqual ?x ?y) Smt.true) (= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (anyNeq ?x ?y) Smt.true) (not (= ?x ?y))) :pattern ((anyNeq ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (= (= (intLess ?x ?y) Smt.true) (< ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intAtMost ?x ?y) Smt.true) (<= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intAtLeast ?x ?y) Smt.true) (>= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intGreater ?x ?y) Smt.true) (> ?x ?y)))) +(assert (distinct Smt.false Smt.true)) +(assert (forall ((?t Int)) (! (subtypes ?t ?t) :pattern ((subtypes ?t ?t)) ))) +(assert (forall ((?t Int) (?u Int) (?v Int)) (! (=> (and (subtypes ?t ?u) (subtypes ?u ?v)) (subtypes ?t ?v)) :pattern ((subtypes ?t ?u) (subtypes ?u ?v)) ))) +(assert (forall ((?t Int) (?u Int)) (! (=> (and (subtypes ?t ?u) (subtypes ?u ?t)) (= ?t ?u)) :pattern ((subtypes ?t ?u) (subtypes ?u ?t)) ))) +(assert (let ((?v_0 (not (= this nullObject))) (?v_1 (forall ((?o_ Int)) (let ((?v_10 (select2 Heap_ ?o_ ownerRef_)) (?v_11 (select2 Heap_ ?o_ ownerFrame_))) (=> (and (not (= ?o_ nullObject)) (= (= (select2 Heap_ ?o_ allocated_) Smt.true) true)) (and (= ?v_10 ?v_10) (= ?v_11 ?v_11)))))) (?v_3 (= return.value_0 nullObject))) (let ((?v_2 (or ?v_3 (and (= (select2 Heap_ return.value_0 ownerRef_) this) (= (select2 Heap_ return.value_0 ownerFrame_) OwnedResults)))) (?v_4 (or ?v_3 (forall ((?pc_ Int)) (let ((?v_12 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 Heap_ ?pc_ ownerRef_) (select2 Heap_ return.value_0 ownerRef_)) (= (select2 Heap_ ?pc_ ownerFrame_) (select2 Heap_ return.value_0 ownerFrame_))) (and (= (select2 Heap_ ?pc_ inv_) ?v_12) (= (select2 Heap_ ?pc_ localinv_) ?v_12))))))) (?v_5 (= ReallyLastGeneratedExit_correct Smt.true)) (?v_6 (= block8840_correct Smt.true)) (?v_7 (= block8823_correct Smt.true)) (?v_8 (= block8806_correct Smt.true)) (?v_9 (= entry_correct Smt.true))) (not (=> (=> (=> true (=> (= (IsHeap Heap_) Smt.true) (=> (= BeingConstructed_ nullObject) (=> (= (AsPureObject_ this) this) (=> (forall ((?pc_ Int)) (let ((?v_13 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 Heap_ ?pc_ ownerRef_) (select2 Heap_ this ownerRef_)) (= (select2 Heap_ ?pc_ ownerFrame_) (select2 Heap_ this ownerFrame_))) (and (= (select2 Heap_ ?pc_ inv_) ?v_13) (= (select2 Heap_ ?pc_ localinv_) ?v_13))))) (=> true (=> (= (IsNotNull_ this OwnedResults) Smt.true) (=> (= (= (select2 Heap_ this allocated_) Smt.true) true) (=> true (=> (=> (=> true (=> true (=> true (=> (=> (=> true (=> true (and ?v_0 (=> ?v_0 (=> (= return.value_0 (select2 Heap_ this OwnedResults.x)) (=> true (=> (=> (=> true (=> true (=> true (=> (=> (=> true (and ?v_1 (=> ?v_1 (and ?v_2 (=> ?v_2 (and ?v_4 (=> ?v_4 (=> true true)))))))) ?v_5) ?v_5)))) ?v_6) ?v_6))))))) ?v_7) ?v_7)))) ?v_8) ?v_8)))))))))) ?v_9) ?v_9))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/Arrays_Q1-noinfer.smt2 b/test/regress/regress1/quantifiers/Arrays_Q1-noinfer.smt2 new file mode 100644 index 000000000..3398f5f84 --- /dev/null +++ b/test/regress/regress1/quantifiers/Arrays_Q1-noinfer.smt2 @@ -0,0 +1,73 @@ +(set-logic AUFLIA) +(set-info :source | + Boogie/Spec# benchmarks. + This benchmark was translated by Michal Moskal. +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun InRange (Int Int) Bool) +(declare-fun o () Int) +(declare-fun q () Int) +(declare-fun int_18446744073709551615 () Int) +(declare-fun Smt.false () Int) +(declare-fun anyEqual (Int Int) Int) +(declare-fun y () Int) +(declare-fun select1 (Int Int) Int) +(declare-fun select2 (Int Int Int) Int) +(declare-fun CONCVARSYM (Int) Int) +(declare-fun divides (Int Int) Int) +(declare-fun intAtMost (Int Int) Int) +(declare-fun subtypes (Int Int) Bool) +(declare-fun store1 (Int Int Int) Int) +(declare-fun store2 (Int Int Int Int) Int) +(declare-fun B_0 () Int) +(declare-fun B_1 () Int) +(declare-fun intAtLeast (Int Int) Int) +(declare-fun int_2147483647 () Int) +(declare-fun boolOr (Int Int) Int) +(declare-fun ReallyLastGeneratedExit_correct () Int) +(declare-fun int_m9223372036854775808 () Int) +(declare-fun Smt.true () Int) +(declare-fun int_4294967295 () Int) +(declare-fun start_correct () Int) +(declare-fun B () Int) +(declare-fun F () Int) +(declare-fun G () Int) +(declare-fun boolAnd (Int Int) Int) +(declare-fun boolNot (Int) Int) +(declare-fun k_0 () Int) +(declare-fun intLess (Int Int) Int) +(declare-fun intGreater (Int Int) Int) +(declare-fun anyNeq (Int Int) Int) +(declare-fun is (Int Int) Int) +(declare-fun int_m2147483648 () Int) +(declare-fun modulo (Int Int) Int) +(declare-fun boolImplies (Int Int) Int) +(declare-fun boolIff (Int Int) Int) +(declare-fun int_9223372036854775807 () Int) +(assert true) +(assert true) +(assert (forall ((?A Int) (?i Int) (?v Int)) (= (select1 (store1 ?A ?i ?v) ?i) ?v))) +(assert (forall ((?A Int) (?i Int) (?j Int) (?v Int)) (=> (not (= ?i ?j)) (= (select1 (store1 ?A ?i ?v) ?j) (select1 ?A ?j))))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?v Int)) (= (select2 (store2 ?A ?o ?f ?v) ?o ?f) ?v))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?o ?p)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) +(assert (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?f ?g)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolIff ?x ?y) Smt.true) (= (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolImplies ?x ?y) Smt.true) (=> (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolAnd ?x ?y) Smt.true) (and (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (= (= (boolOr ?x ?y) Smt.true) (or (= ?x Smt.true) (= ?y Smt.true))))) +(assert (forall ((?x Int)) (! (= (= (boolNot ?x) Smt.true) (not (= ?x Smt.true))) :pattern ((boolNot ?x)) ))) +(assert (forall ((?x Int) (?y Int)) (= (= (anyEqual ?x ?y) Smt.true) (= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (anyNeq ?x ?y) Smt.true) (not (= ?x ?y))) :pattern ((anyNeq ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (= (= (intLess ?x ?y) Smt.true) (< ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intAtMost ?x ?y) Smt.true) (<= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intAtLeast ?x ?y) Smt.true) (>= ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (= (intGreater ?x ?y) Smt.true) (> ?x ?y)))) +(assert (distinct Smt.false Smt.true)) +(assert (forall ((?t Int)) (! (subtypes ?t ?t) :pattern ((subtypes ?t ?t)) ))) +(assert (forall ((?t Int) (?u Int) (?v Int)) (! (=> (and (subtypes ?t ?u) (subtypes ?u ?v)) (subtypes ?t ?v)) :pattern ((subtypes ?t ?u) (subtypes ?u ?v)) ))) +(assert (forall ((?t Int) (?u Int)) (! (=> (and (subtypes ?t ?u) (subtypes ?u ?t)) (= ?t ?u)) :pattern ((subtypes ?t ?u) (subtypes ?u ?t)) ))) +(assert (let ((?v_0 (forall ((?p Int) (?f Int)) (or (= (select2 B_1 ?p ?f) (select2 B ?p ?f)) (and (= ?p o) (= ?f F))))) (?v_1 (= ReallyLastGeneratedExit_correct Smt.true)) (?v_2 (= start_correct Smt.true))) (not (=> (=> (=> true (=> (= k_0 (select2 B q G)) (=> (= B_0 (store2 B o F (+ y (select2 B o F)))) (=> (= B_1 (store2 B_0 q G k_0)) (=> (=> (=> true (and ?v_0 (=> ?v_0 (=> true true)))) ?v_1) ?v_1))))) ?v_2) ?v_2)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/Makefile.am b/test/regress/regress1/quantifiers/Makefile.am index cc5834a31..7d3da3654 100644 --- a/test/regress/regress1/quantifiers/Makefile.am +++ b/test/regress/regress1/quantifiers/Makefile.am @@ -17,9 +17,80 @@ endif # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" TESTS = \ - bug802.smt2 + bug802.smt2 \ + 006-cbqi-ite.smt2 \ + AdditiveMethods_OwnedResults.Mz.smt2 \ + ari118-bv-2occ-x.smt2 \ + array-unsat-simp3.smt2 \ + bignum_quant.smt2 \ + bug_743.smt2 \ + bug822.smt2 \ + cdt-0208-to.smt2 \ + gauss_init_0030.fof.smt2 \ + inst-max-level-segf.smt2 \ + intersection-example-onelane.proof-node22337.smt2 \ + javafe.ast.StmtVec.009.smt2 \ + model_6_1_bv.smt2 \ + nested9_true-unreach-call.i_575.smt2 \ + NUM878.smt2 \ + opisavailable-12.smt2 \ + psyco-107-bv.smt2 \ + psyco-196.smt2 \ + qbv-simple-2vars-vo.smt2 \ + qbv-test-invert-bvcomp.smt2 \ + qbv-test-invert-bvudiv-0.smt2 \ + qbv-test-invert-bvudiv-1.smt2 \ + qbv-test-invert-bvurem-1.smt2 \ + qcft-javafe.filespace.TreeWalker.006.smt2 \ + qcft-smtlib3dbc51.smt2 \ + quaternion_ds1_symm_0428.fof.smt2 \ + rew-to-0211-dd.smt2 \ + ricart-agrawala6.smt2 \ + RND_4_16.smt2 \ + small-pipeline-fixpoint-3.smt2 \ + smtlib384a03.smt2 \ + smtlib46f14a.smt2 \ + smtlibf957ea.smt2 \ + stream-x2014-09-18-unsat.smt2 \ + symmetric_unsat_7.smt2 \ + anti-sk-simp.smt2 \ + Arrays_Q1-noinfer.smt2 \ + bi-artm-s.smt2 \ + burns13.smt2 \ + burns4.smt2 \ + cbqi-sdlx-fixpoint-3-dd.smt2 \ + ext-ex-deq-trigger.smt2 \ + extract-nproc.smt2 \ + florian-case-ax.smt2 \ + is-even.smt2 \ + mix-coeff.smt2 \ + parametric-lists.smt2 \ + psyco-001-bv.smt2 \ + qbv-disequality3.smt2 \ + qbv-test-invert-bvashr-0.smt2 \ + qbv-test-invert-bvashr-1.smt2 \ + qbv-test-invert-bvlshr-1.smt2 \ + qbv-test-invert-bvmul-neq.smt2 \ + qbv-test-invert-bvmul.smt2 \ + qbv-test-invert-bvudiv-0-neq.smt2 \ + qbv-test-invert-bvudiv-1-neq.smt2 \ + qbv-test-invert-bvurem-1-neq.smt2 \ + qbv-test-urem-rewrite.smt2 \ + RND-small.smt2 \ + RNDPRE_4_1-dd-nqe.smt2 \ + set8.smt2 \ + z3.620661-no-fv-trigger.smt2 -EXTRA_DIST = $(TESTS) +# removed because they take more than 20s +# javafe.ast.ArrayInit.35.smt2 + +# FIXME: I've disabled these since they give different error messages on production and debug +# macro-subtype-param.smt2 +# subtype-param-unk.smt2 +# subtype-param.smt2 + +EXTRA_DIST = $(TESTS) \ + set3.smt2 # synonyms for "check" in this directory .PHONY: regress regress1 test diff --git a/test/regress/regress1/quantifiers/NUM878.smt2 b/test/regress/regress1/quantifiers/NUM878.smt2 new file mode 100644 index 000000000..8d78bf861 --- /dev/null +++ b/test/regress/regress1/quantifiers/NUM878.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --cbqi-bv +; EXPECT: unsat +(set-logic BV) +(set-info :status unsat) +(assert (not (exists ((?X (_ BitVec 32))) (= (bvmul ?X ?X) ?X)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/RND-small.smt2 b/test/regress/regress1/quantifiers/RND-small.smt2 new file mode 100644 index 000000000..cf5c3bc7e --- /dev/null +++ b/test/regress/regress1/quantifiers/RND-small.smt2 @@ -0,0 +1,9 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic LRA) +(declare-fun y1 () Real) +(declare-fun y2 () Real) +(declare-fun x1 () Real) +(assert (forall ((?y1 Real)) (exists ((?y2 Real)) (or (and (>= (+ (+ (* 69 ?y2) (* (- 80) ?y1)) (* 48 x1)) (- 77)) (and (not (= (+ (* (- 1) ?y2) (* (- 48) x1)) 0)) (not (= (+ (* 14 ?y1) (* (- 98) x1)) 83)))) (and (and (<= (+ (+ (* (- 95) ?y2) (* 34 ?y1)) (* (- 54) x1)) 51) (= (+ (+ (* 27 ?y2) (* (- 17) ?y1)) (* 75 x1)) 24)) (not (= (+ (* (- 96) ?y1) (* 90 x1)) (- 39)))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/RNDPRE_4_1-dd-nqe.smt2 b/test/regress/regress1/quantifiers/RNDPRE_4_1-dd-nqe.smt2 new file mode 100644 index 000000000..6379d6cec --- /dev/null +++ b/test/regress/regress1/quantifiers/RNDPRE_4_1-dd-nqe.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --cbqi-nested-qe +; EXPECT: unsat +(set-logic LRA) + +(declare-fun c () Real) + +(assert +(forall ((?x2 Real)) +(exists ((?x3 Real)) +(and +(forall ((?x4 Real)) (or +(not (>= ?x4 4)) +(and (> c (+ ?x2 ?x3)) (> (+ c ?x3 ?x4) 0))) ) +(not (> (+ c ?x2 ?x3) 0)) ) +)) ) + +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/RND_4_16.smt2 b/test/regress/regress1/quantifiers/RND_4_16.smt2 new file mode 100644 index 000000000..2bdb1f56e --- /dev/null +++ b/test/regress/regress1/quantifiers/RND_4_16.smt2 @@ -0,0 +1,10 @@ +(set-logic LRA) +(set-info :status unsat) +(declare-fun y2 () Real) +(declare-fun y3 () Real) +(declare-fun y4 () Real) +(declare-fun x1 () Real) +(declare-fun y1 () Real) +(assert (or (and (and (and (exists ((?y2 Real)) (or (forall ((?y3 Real)) (forall ((?y4 Real)) (or (< (+ (+ (* (- 53) ?y4) (* 77 ?y3)) (* 51 ?y2)) 79) (not (= (* (- 56) ?y4) 0))))) (or (exists ((?y3 Real)) (not (= (+ (* (- 94) ?y2) (* 90 x1)) (- 54)))) (and (<= (+ (* (- 28) ?y2) (* 4 x1)) 62) (exists ((?y3 Real)) (>= (+ (+ (* (- 83) ?y3) (* (- 2) ?y2)) (* 78 x1)) 34)))))) (forall ((?y1 Real)) (forall ((?y2 Real)) (and (forall ((?y4 Real)) (or (= (+ (* (- 27) ?y1) (* (- 64) x1)) 12) (< (+ (+ (* (- 91) ?y4) (* (- 61) ?y1)) (* 20 x1)) 25))) (or (forall ((?y4 Real)) (> (+ (+ (+ (* 22 ?y4) (* (- 35) ?y2)) (* (- 77) ?y1)) (* (- 78) x1)) (- 49))) (and (= (+ (* (- 55) ?y1) (* (- 71) x1)) 51) (<= (* (- 2) ?y1) 0))))))) (or (and (forall ((?y1 Real)) (exists ((?y2 Real)) (forall ((?y3 Real)) (and (>= (+ (* (- 42) ?y2) (* (- 88) ?y1)) 0) (not (= (+ (* 94 ?y3) (* (- 41) ?y2)) 20)))))) (exists ((?y1 Real)) (forall ((?y2 Real)) (exists ((?y3 Real)) (forall ((?y4 Real)) (or (<= (+ (+ (* 84 ?y4) (* 79 ?y3)) (* 42 ?y2)) 5) (= (+ (+ (* (- 58) ?y3) (* (- 13) ?y2)) (* 93 x1)) (- 1)))))))) (or (and (or (= (* 21 x1) (- 18)) (>= (* 76 x1) 0)) (or (>= (* (- 79) x1) 61) (>= (* (- 32) x1) (- 26)))) (and (and (or (>= (* (- 44) x1) 58) (not (= (* (- 68) x1) (- 93)))) (forall ((?y3 Real)) (>= (* (- 14) x1) 91))) (forall ((?y2 Real)) (and (and (> (* (- 65) x1) 74) (>= (+ (* 27 ?y2) (* (- 84) x1)) (- 68))) (and (>= (+ (* 11 ?y2) (* (- 77) x1)) 0) (< (+ (* (- 67) ?y2) (* (- 42) x1)) 88)))))))) (forall ((?y1 Real)) (exists ((?y2 Real)) (exists ((?y3 Real)) (forall ((?y4 Real)) (let ((?v_0 (* 66 ?y4))) (and (or (>= (+ (+ (+ (* 48 ?y4) (* (- 47) ?y3)) (* 1 ?y1)) (* 38 x1)) 61) (>= (+ (+ (* (- 19) ?y4) (* (- 80) ?y3)) (* (- 66) ?y2)) 25)) (or (or (and (<= (+ (+ (* (- 4) ?y4) (* (- 22) ?y2)) (* (- 18) ?y1)) (- 28)) (not (= (+ (+ (+ (* 1 ?y3) (* 20 ?y2)) (* (- 42) ?y1)) (* 74 x1)) (- 63)))) (and (= (+ (+ (+ (* 13 ?y3) (* (- 7) ?y2)) (* 52 ?y1)) (* 94 x1)) 0) (< (+ (+ (+ (+ (* 87 ?y4) (* (- 36) ?y3)) (* 55 ?y2)) (* (- 99) ?y1)) (* (- 56) x1)) (- 98)))) (or (or (not (= (+ (+ (+ (+ (* 73 ?y4) (* (- 15) ?y3)) (* 52 ?y2)) (* 12 ?y1)) (* 69 x1)) 72)) (<= (+ (+ ?v_0 (* (- 89) ?y1)) (* (- 49) x1)) 47)) (and (>= (+ (+ (* 82 ?y3) (* 69 ?y2)) (* 67 ?y1)) 10) (= (+ (+ (+ ?v_0 (* 4 ?y3)) (* 21 ?y2)) (* (- 35) ?y1)) 77))))))))))) (exists ((?y1 Real)) (forall ((?y2 Real)) (and (forall ((?y3 Real)) (forall ((?y4 Real)) (let ((?v_1 (* (- 41) ?y2))) (or (and (and (not (= (+ (+ (+ (* 33 ?y3) (* 7 ?y2)) (* 84 ?y1)) (* (- 79) x1)) 0)) (and (< (+ (+ (+ (* 57 ?y4) ?v_1) (* (- 82) ?y1)) (* (- 5) x1)) 40) (>= (+ (+ (+ (* 18 ?y3) (* (- 64) ?y2)) (* (- 87) ?y1)) (* (- 37) x1)) 16))) (and (or (not (= (+ (+ (+ (+ (* (- 19) ?y4) (* (- 74) ?y3)) (* 40 ?y2)) (* (- 73) ?y1)) (* (- 81) x1)) (- 6))) (< (+ (+ (+ (* (- 86) ?y4) (* (- 83) ?y2)) (* 46 ?y1)) (* (- 74) x1)) 94)) (or (> (+ (* (- 69) ?y2) (* (- 45) ?y1)) 0) (>= (+ (+ (* 16 ?y4) (* (- 18) ?y3)) (* (- 92) ?y2)) (- 32))))) (and (and (or (not (= (+ (+ (+ (* 11 ?y4) (* 75 ?y3)) (* 6 ?y1)) (* (- 63) x1)) 57)) (not (= (+ (+ (+ (+ (* (- 90) ?y4) (* 48 ?y3)) (* (- 94) ?y2)) (* (- 48) ?y1)) (* 96 x1)) (- 45)))) (or (>= (+ (+ (+ (* 36 ?y4) (* 67 ?y3)) (* 11 ?y2)) (* (- 84) x1)) (- 8)) (>= (+ (+ (* 75 ?y4) (* (- 65) ?y2)) (* (- 77) x1)) 34))) (or (or (> (+ (* 70 ?y1) (* (- 85) x1)) 0) (<= (+ (* 3 ?y2) (* (- 78) ?y1)) (- 7))) (and (= (+ (+ (* 44 ?y4) ?v_1) (* 48 x1)) 0) (< (+ (+ (+ (+ (* 27 ?y4) (* (- 24) ?y3)) (* 89 ?y2)) (* (- 93) ?y1)) (* 65 x1)) (- 17))))))))) (forall ((?y4 Real)) (let ((?v_2 (* 11 x1))) (and (and (or (and (< (* 99 ?y4) (- 32)) (<= (+ (+ (* 47 ?y4) (* (- 90) ?y1)) (* 78 x1)) (- 33))) (= (+ (* (- 19) ?y2) (* (- 97) ?y1)) 5)) (and (and (<= (+ (+ (* (- 54) ?y2) (* (- 87) ?y1)) (* (- 32) x1)) 51) (> (+ (+ (+ (* 46 ?y4) (* (- 11) ?y2)) (* (- 68) ?y1)) (* 77 x1)) 77)) (and (< (+ (+ (* 1 ?y4) (* 53 ?y2)) (* (- 60) x1)) (- 86)) (< (+ (* (- 12) ?y2) (* 38 x1)) 79)))) (or (or (>= (+ (* (- 46) ?y2) ?v_2) 37) (= (* (- 2) ?y1) 50)) (or (not (= (+ (+ (+ (* (- 95) ?y4) (* (- 96) ?y2)) (* (- 74) ?y1)) (* 59 x1)) (- 24))) (< (+ (* (- 70) ?y1) ?v_2) 0))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/anti-sk-simp.smt2 b/test/regress/regress1/quantifiers/anti-sk-simp.smt2 new file mode 100644 index 000000000..2ae54a075 --- /dev/null +++ b/test/regress/regress1/quantifiers/anti-sk-simp.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi --quant-anti-skolem +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-fun f (Int) Int) +(declare-fun a () Int) +(declare-fun b () Int) +(assert (forall ((X Int)) (< X (f X)))) +(assert (forall ((X Int)) (> (+ a b) (f X)))) +(check-sat) diff --git a/test/regress/regress1/quantifiers/ari118-bv-2occ-x.smt2 b/test/regress/regress1/quantifiers/ari118-bv-2occ-x.smt2 new file mode 100644 index 000000000..2d70dfb8e --- /dev/null +++ b/test/regress/regress1/quantifiers/ari118-bv-2occ-x.smt2 @@ -0,0 +1,8 @@ +; COMMAND-LINE: --cbqi-bv +; EXPECT: unsat +(set-logic BV) +(set-info :status unsat) +; two occurrences of x +(assert (not (exists ((?X (_ BitVec 32)) (?Y (_ BitVec 32))) (= (bvmul ?X ?Y) ?X)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/array-unsat-simp3.smt2 b/test/regress/regress1/quantifiers/array-unsat-simp3.smt2 new file mode 100644 index 000000000..9dade2073 --- /dev/null +++ b/test/regress/regress1/quantifiers/array-unsat-simp3.smt2 @@ -0,0 +1,23 @@ +; COMMAND-LINE: --full-saturate-quant +; EXPECT: unsat +(set-logic AUFLIA) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-sort Index 0) +(declare-sort Element 0) +(declare-sort Array_uf 0) +(declare-fun store_uf (Array_uf Index Element) Array_uf) +(declare-fun select_uf (Array_uf Index) Element) +(declare-fun a1 () Array_uf) +(declare-fun e1 () Element) +(declare-fun e2 () Element) +(declare-fun i1 () Index) +(declare-fun i2 () Index) +(assert (forall ((?a Array_uf) (?i Index) (?e Element)) (= (select_uf (store_uf ?a ?i ?e) ?i) ?e))) +(assert (forall ((?a Array_uf) (?i Index) (?j Index) (?e Element)) (or (= ?i ?j)(= (select_uf (store_uf ?a ?i ?e) ?j) (select_uf ?a ?j))))) +(assert (forall ((?a Array_uf) (?b Array_uf)) (=> (forall ((?i Index)) (= (select_uf ?a ?i) (select_uf ?b ?i))) (= ?a ?b)))) +(assert (not (= i1 i2))) +(assert (not (= (store_uf (store_uf a1 i1 e1) i2 e2) (store_uf (store_uf a1 i2 e2) i1 e1)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/bi-artm-s.smt2 b/test/regress/regress1/quantifiers/bi-artm-s.smt2 new file mode 100644 index 000000000..b97c339fc --- /dev/null +++ b/test/regress/regress1/quantifiers/bi-artm-s.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --fmf-bound-lazy +; EXPECT: unsat +(set-option :incremental "false") +(set-info :status unsat) +(set-logic ALL_SUPPORTED) +(declare-fun Y () String) +(set-info :notes "ufP_1 is uf type conv P") +(declare-fun ufP_1 (Int) Int) +(set-info :notes "ufM_2 is uf type conv M") +(declare-fun ufM_2 (Int) Int) +(declare-fun z1_3 () String) +(declare-fun z2_4 () String) +(declare-fun z3_5 () String) +(declare-fun V_253 () String) +(declare-fun V_254 () String) + +(assert (or (= Y "1") (= Y "0"))) +(assert (>= (ufP_1 0) 32)) +(assert + +(forall ((V_243 Int)) +(or +(not (and (>= V_243 0) (>= (+ (str.len Y) (* (- 1) V_243)) 1))) +(and +(or (not (= (str.len Y) (+ 1 V_243))) (= (ufP_1 V_243) (ufM_2 V_243))) +(not (>= (ufM_2 V_243) 10)) +(not (or (not (= (str.len Y) (+ 1 V_243 (str.len V_253)))) (not (= Y (str.++ V_253 (ite (= (ufM_2 V_243) 0) "0" "1") V_254)))) ))) )) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/bignum_quant.smt2 b/test/regress/regress1/quantifiers/bignum_quant.smt2 new file mode 100644 index 000000000..74b08a2da --- /dev/null +++ b/test/regress/regress1/quantifiers/bignum_quant.smt2 @@ -0,0 +1,12 @@ +(set-logic AUFLIA) +(set-info :source | SMT-COMP'06 organizers |) +(set-info :smt-lib-version 2.0) +(set-info :category "check") +(set-info :status unsat) +(set-info :notes |This benchmark is designed to check if the DP supports bignumbers.|) +(declare-fun f (Int) Int) +(assert (= (f 0) 1)) +(assert (forall ((?x Int)) (=> (> ?x 0) (= (f ?x) (* (- 1000) (f (- ?x 1))))))) +(assert (< (f 20) 0)) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/bug822.smt2 b/test/regress/regress1/quantifiers/bug822.smt2 new file mode 100644 index 000000000..cc1b5ed50 --- /dev/null +++ b/test/regress/regress1/quantifiers/bug822.smt2 @@ -0,0 +1,1181 @@ +(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) + diff --git a/test/regress/regress1/quantifiers/bug_743.smt2 b/test/regress/regress1/quantifiers/bug_743.smt2 new file mode 100644 index 000000000..ec5a5149e --- /dev/null +++ b/test/regress/regress1/quantifiers/bug_743.smt2 @@ -0,0 +1,777 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: unsat + +;; produced by cvc4_14.drv ;; +(set-logic AUFBVDTNIRA) +(set-info :source |VC generated by SPARK 2014|) +(set-info :smt-lib-version 2.0) +(set-info :category industrial) +(set-info :status unsat) +;;; generated by SMT-LIB2 driver +;;; SMT-LIB2 driver: bit-vectors, common part +;;; SMT-LIB2: integer arithmetic +(declare-datatypes () ((tuple0 (Tuple0)))) +(declare-sort us_private 0) + +(declare-fun us_null_ext__ () us_private) + +(declare-sort us_type_of_heap 0) + +(declare-datatypes () +((us_type_of_heap__ref + (mk___type_of_heap__ref (us_type_of_heap__content us_type_of_heap))))) +(declare-sort us_image 0) + +(declare-datatypes () ((int__ref (mk_int__ref (int__content Int))))) +(declare-datatypes () ((bool__ref (mk_bool__ref (bool__content Bool))))) +(declare-datatypes () ((real__ref (mk_real__ref (real__content Real))))) +(declare-datatypes () +((us_private__ref (mk___private__ref (us_private__content us_private))))) +(define-fun int__ref___projection ((a int__ref)) Int (int__content a)) + +(define-fun bool__ref___projection ((a bool__ref)) Bool (bool__content a)) + +(define-fun real__ref___projection ((a real__ref)) Real (real__content a)) + +(define-fun us_private__ref___projection ((a us_private__ref)) us_private + (us_private__content a)) + +(declare-fun us_compatible_tags (Int Int) Bool) + +;; __compatible_tags_refl + (assert (forall ((tag Int)) (us_compatible_tags tag tag))) + +(define-fun to_int1 ((b Bool)) Int (ite (= b true) 1 0)) + +(define-fun of_int ((i Int)) Bool (ite (= i 0) false true)) + +(define-fun in_range ((x Int)) Bool (or (= x 0) (= x 1))) + +(declare-fun attr__ATTRIBUTE_IMAGE (Bool) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE (us_image) Bool) + +(declare-sort integer 0) + +(define-fun in_range1 ((x Int)) Bool (and (<= (- 2147483648) x) + (<= x 2147483647))) + +(define-fun bool_eq ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE1 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check1 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE1 (us_image) Int) + +(declare-fun to_rep (integer) Int) + +(declare-fun of_rep (Int) integer) + +(declare-fun user_eq (integer integer) Bool) + +(declare-fun dummy () integer) + +;; inversion_axiom + (assert + (forall ((x integer)) (! (= (of_rep (to_rep x)) x) :pattern ((to_rep x)) +))) + +;; range_axiom + (assert + (forall ((x integer)) (! (in_range1 (to_rep x)) :pattern ((to_rep x)) +))) + +;; coerce_axiom + (assert + (forall ((x Int)) + (! (=> (in_range1 x) (= (to_rep (of_rep x)) x)) :pattern ((to_rep + (of_rep x))) +))) + +(declare-datatypes () +((integer__ref (mk_integer__ref (integer__content integer))))) +(define-fun integer__ref___projection ((a integer__ref)) integer +(integer__content + a)) + +(declare-sort natural 0) + +(define-fun in_range2 ((x Int)) Bool (and (<= 0 x) (<= x 2147483647))) + +(define-fun bool_eq1 ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE2 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check2 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE2 (us_image) Int) + +(declare-fun to_rep1 (natural) Int) + +(declare-fun of_rep1 (Int) natural) + +(declare-fun user_eq1 (natural natural) Bool) + +(declare-fun dummy1 () natural) + +;; inversion_axiom + (assert + (forall ((x natural)) + (! (= (of_rep1 (to_rep1 x)) x) :pattern ((to_rep1 x)) ))) + +;; range_axiom + (assert + (forall ((x natural)) (! (in_range2 (to_rep1 x)) :pattern ((to_rep1 x)) +))) + +;; coerce_axiom + (assert + (forall ((x Int)) + (! (=> (in_range2 x) (= (to_rep1 (of_rep1 x)) x)) :pattern ((to_rep1 + (of_rep1 +x))) ))) + +(declare-datatypes () +((natural__ref (mk_natural__ref (natural__content natural))))) +(define-fun natural__ref___projection ((a natural__ref)) natural +(natural__content + a)) + +(define-fun dynamic_invariant ((temp___expr_33 Int) (temp___is_init_30 +Bool) + (temp___do_constant_31 Bool) + (temp___do_toplevel_32 Bool)) Bool (=> + (or (= temp___is_init_30 true) + (<= 0 2147483647)) (in_range2 + temp___expr_33))) + +(declare-sort index 0) + +(define-fun in_range3 ((x Int)) Bool (and (<= 1 x) (<= x 100))) + +(define-fun bool_eq2 ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE3 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check3 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE3 (us_image) Int) + +(declare-fun to_rep2 (index) Int) + +(declare-fun of_rep2 (Int) index) + +(declare-fun user_eq2 (index index) Bool) + +(declare-fun dummy2 () index) + +;; inversion_axiom + (assert + (forall ((x index)) + (! (= (of_rep2 (to_rep2 x)) x) :pattern ((to_rep2 x)) ))) + +;; range_axiom + (assert + (forall ((x index)) (! (in_range3 (to_rep2 x)) :pattern ((to_rep2 x)) +))) + +;; coerce_axiom + (assert + (forall ((x Int)) + (! (=> (in_range3 x) (= (to_rep2 (of_rep2 x)) x)) :pattern ((to_rep2 + (of_rep2 +x))) ))) + +(declare-datatypes () ((index__ref (mk_index__ref (index__content +index))))) +(define-fun index__ref___projection ((a index__ref)) index (index__content +a)) + +(define-fun dynamic_invariant1 ((temp___expr_144 Int) + (temp___is_init_141 Bool) (temp___do_constant_142 Bool) + (temp___do_toplevel_143 Bool)) Bool (=> + (or (= temp___is_init_141 true) + (<= 1 100)) (in_range3 + temp___expr_144))) + +(declare-datatypes () +((map__ref (mk_map__ref (map__content (Array Int natural)))))) +(declare-fun bool_eq3 ((Array Int natural) Int Int (Array Int natural) Int + Int) Bool) + +;; T__ada_array___equal_def + (assert + (forall ((a (Array Int natural))) + (forall ((af Int)) + (forall ((al Int)) + (forall ((b (Array Int natural))) + (forall ((bf Int)) + (forall ((bl Int)) + (! (= + (and (ite (<= af al) (= (+ (- al af) 1) (+ (- bl bf) 1)) (< bl bf)) + (forall ((i Int)) + (! (=> (and (<= af i) (<= i al)) + (= (select a i) (select b (+ (- bf af) i)))) :pattern ((select a +i)) ))) + (= (bool_eq3 a af al b bf bl) true)) :pattern ((bool_eq3 a af al b bf + bl)) )))))))) + +(declare-fun slide ((Array Int natural) Int Int) (Array Int natural)) + +;; slide_eq + (assert + (forall ((a (Array Int natural))) + (forall ((first Int)) + (! (= (slide a first first) a) :pattern ((slide a first first)) )))) + +;; slide_def + (assert + (forall ((a (Array Int natural))) + (forall ((old_first Int)) + (forall ((new_first Int)) + (forall ((i Int)) + (! (= (select (slide a old_first new_first) i) (select a (- i (- +new_first old_first)))) :pattern ((select + (slide a old_first new_first) i)) )))))) + +(declare-fun concat1 ((Array Int natural) Int Int (Array Int natural) Int + Int) (Array Int natural)) + +;; concat_def + (assert + (forall ((a (Array Int natural)) (b (Array Int natural))) + (forall ((a_first Int) (a_last Int) (b_first Int) (b_last Int)) + (forall ((i Int)) + (! (and + (=> (and (<= a_first i) (<= i a_last)) + (= (select (concat1 a a_first a_last b b_first b_last) i) (select a +i))) + (=> (< a_last i) + (= (select (concat1 a a_first a_last b b_first b_last) i) (select b +(+ (- i a_last) (- b_first 1)))))) :pattern ((select + (concat1 a a_first a_last b b_first b_last) i)) ))))) + +(declare-fun singleton (natural Int) (Array Int natural)) + +;; singleton_def + (assert + (forall ((v natural)) + (forall ((i Int)) + (! (= (select (singleton v i) i) v) :pattern ((select (singleton v i) +i)) )))) + +(declare-fun compare ((Array Int natural) Int Int (Array Int natural) Int + Int) Int) + +;; compare_def + (assert + (forall ((a (Array Int natural)) (b (Array Int natural))) + (forall ((a_first Int) (a_last Int) (b_first Int) (b_last Int)) + (! (and + (= (= (compare a a_first a_last b b_first b_last) 0) + (= (bool_eq3 a a_first a_last b b_first b_last) true)) + (and + (= (< (compare a a_first a_last b b_first b_last) 0) + (exists ((i Int) (j Int)) + (and (<= i a_last) + (and (< j b_last) + (and (= (bool_eq3 a a_first i b b_first j) true) + (or (= i a_last) + (and (< i a_last) + (< (to_rep1 (select a (+ i 1))) (to_rep1 (select b (+ j 1))))))))))) + (= (< 0 (compare a a_first a_last b b_first b_last)) + (exists ((i Int) (j Int)) + (and (<= i b_last) + (and (< j a_last) + (and (= (bool_eq3 a a_first j b b_first i) true) + (or (= i b_last) + (and (< i b_last) + (< (to_rep1 (select b (+ i 1))) (to_rep1 (select a (+ j +1))))))))))))) :pattern ( + (compare a a_first a_last b b_first b_last)) )))) + +(declare-sort t 0) + +(declare-fun first (t) integer) + +(declare-fun last (t) integer) + +(declare-fun mk (Int Int) t) + +;; mk_def + (assert + (forall ((f Int) (l Int)) + (! (=> (in_range1 f) + (=> (in_range1 l) + (and (= (to_rep (first (mk f l))) f) (= (to_rep (last (mk f l))) +l)))) :pattern ( + (mk f l)) ))) + +(define-fun dynamic_property ((range_first Int) (range_last Int) (low Int) + (high Int)) Bool (and (in_range1 low) + (and (in_range1 high) + (=> (<= low high) (and (in_range3 low) (in_range3 +high)))))) + +(declare-datatypes () ((us_t (mk___t (elts (Array Int natural))(rt t))))) +(define-fun to_array ((a us_t)) (Array Int natural) (elts a)) + +(define-fun of_array ((a (Array Int natural)) (f Int) + (l Int)) us_t (mk___t a (mk f l))) + +(define-fun first1 ((a us_t)) Int (to_rep (first (rt a)))) + +(define-fun last1 ((a us_t)) Int (to_rep (last (rt a)))) + +(define-fun length ((a us_t)) Int (ite (<= (first1 a) (last1 a)) + (+ (- (last1 a) (first1 a)) 1) 0)) + +(declare-fun value__size () Int) + +(declare-fun object__size ((Array Int natural)) Int) + +(declare-fun value__component__size () Int) + +(declare-fun object__component__size ((Array Int natural)) Int) + +(declare-fun value__alignment () Int) + +(declare-fun object__alignment ((Array Int natural)) Int) + +;; value__size_axiom + (assert (<= 0 value__size)) + +;; object__size_axiom + (assert (forall ((a (Array Int natural))) (<= 0 (object__size a)))) + +;; value__component__size_axiom + (assert (<= 0 value__component__size)) + +;; object__component__size_axiom + (assert + (forall ((a (Array Int natural))) (<= 0 (object__component__size a)))) + +;; value__alignment_axiom + (assert (<= 0 value__alignment)) + +;; object__alignment_axiom + (assert (forall ((a (Array Int natural))) (<= 0 (object__alignment a)))) + +(define-fun bool_eq4 ((x us_t) + (y us_t)) Bool (bool_eq3 (elts x) (to_rep (first (rt x))) + (to_rep (last (rt x))) (elts y) (to_rep (first (rt y))) + (to_rep (last (rt y))))) + +(declare-fun user_eq3 (us_t us_t) Bool) + +(declare-fun dummy3 () us_t) + +(declare-datatypes () +((nat_array__ref (mk_nat_array__ref (nat_array__content us_t))))) +(define-fun nat_array__ref___projection ((a nat_array__ref)) us_t +(nat_array__content + a)) + +(define-fun dynamic_invariant2 ((temp___expr_150 us_t) + (temp___is_init_147 Bool) (temp___do_constant_148 Bool) + (temp___do_toplevel_149 Bool)) Bool (=> + (not (= temp___do_constant_148 +true)) + (dynamic_property 1 100 + (first1 temp___expr_150) + (last1 temp___expr_150)))) + +(declare-fun remove_last (us_t) us_t) + +(declare-fun first2 () Int) + +(declare-fun last2 () Int) + +(define-fun dynamic_property1 ((first_int Int) (last_int Int) + (x Int)) Bool (and (<= first_int x) (<= x last_int))) + +(define-fun bool_eq5 ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE4 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check4 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE4 (us_image) Int) + +(declare-fun user_eq4 (integer integer) Bool) + +(declare-fun dummy4 () integer) + +(declare-datatypes () ((t15s__ref (mk_t15s__ref (t15s__content +integer))))) +(define-fun t15s__ref___projection ((a t15s__ref)) integer (t15s__content +a)) + +(declare-sort t1 0) + +(declare-fun first3 (t1) integer) + +(declare-fun last3 (t1) integer) + +(declare-fun mk1 (Int Int) t1) + +;; mk_def + (assert + (forall ((f Int) (l Int)) + (! (=> (in_range1 f) + (=> (in_range1 l) + (and (= (to_rep (first3 (mk1 f l))) f) (= (to_rep (last3 (mk1 f l))) +l)))) :pattern ( + (mk1 f l)) ))) + +(define-fun dynamic_property2 ((range_first Int) (range_last Int) (low +Int) + (high Int)) Bool (and (in_range1 low) + (and (in_range1 high) + (=> (<= low high) + (and (dynamic_property1 range_first range_last low) + (dynamic_property1 range_first range_last high)))))) + +(declare-datatypes () +((us_t1 (mk___t1 (elts1 (Array Int natural))(rt1 t1))))) +(define-fun to_array1 ((a us_t1)) (Array Int natural) (elts1 a)) + +(define-fun of_array1 ((a (Array Int natural)) (f Int) + (l Int)) us_t1 (mk___t1 a (mk1 f l))) + +(define-fun first4 ((a us_t1)) Int (to_rep (first3 (rt1 a)))) + +(define-fun last4 ((a us_t1)) Int (to_rep (last3 (rt1 a)))) + +(define-fun length1 ((a us_t1)) Int (ite (<= (first4 a) (last4 a)) + (+ (- (last4 a) (first4 a)) 1) 0)) + +(declare-fun value__size1 () Int) + +(declare-fun object__size1 ((Array Int natural)) Int) + +(declare-fun value__component__size1 () Int) + +(declare-fun object__component__size1 ((Array Int natural)) Int) + +(declare-fun value__alignment1 () Int) + +(declare-fun object__alignment1 ((Array Int natural)) Int) + +;; value__size_axiom + (assert (<= 0 value__size1)) + +;; object__size_axiom + (assert (forall ((a (Array Int natural))) (<= 0 (object__size1 a)))) + +;; value__component__size_axiom + (assert (<= 0 value__component__size1)) + +;; object__component__size_axiom + (assert + (forall ((a (Array Int natural))) (<= 0 (object__component__size1 a)))) + +;; value__alignment_axiom + (assert (<= 0 value__alignment1)) + +;; object__alignment_axiom + (assert (forall ((a (Array Int natural))) (<= 0 (object__alignment1 +a)))) + +(define-fun bool_eq6 ((x us_t1) + (y us_t1)) Bool (bool_eq3 (elts1 x) (to_rep (first3 (rt1 x))) + (to_rep (last3 (rt1 x))) (elts1 y) + (to_rep (first3 (rt1 y))) (to_rep (last3 (rt1 y))))) + +(declare-fun user_eq5 (us_t1 us_t1) Bool) + +(declare-fun dummy5 () us_t1) + +(declare-datatypes () ((t16s__ref (mk_t16s__ref (t16s__content us_t1))))) +(define-fun t16s__ref___projection ((a t16s__ref)) us_t1 (t16s__content +a)) + +;; remove_last__post_axiom + (assert + (forall ((a us_t)) + (! (=> (and (dynamic_invariant2 a true true true) (< 0 (length a))) + (dynamic_invariant2 (remove_last a) true false true)) :pattern ( + (remove_last a)) ))) + +;; remove_last__def_axiom + (assert + (forall ((a us_t)) + (! (=> (dynamic_invariant2 a true true true) + (= (remove_last a) (let ((temp___163 (let ((temp___162 (- (last1 a) +1))) + (let ((temp___161 (first1 a))) + (of_array1 (to_array a) +temp___161 + temp___162))))) + (of_array (to_array1 temp___163) (first4 +temp___163) + (last4 temp___163))))) :pattern ((remove_last a)) +))) + +(declare-fun occ (us_t Int) Int) + +(declare-sort nb_occ 0) + +(define-fun in_range4 ((x Int)) Bool (and (<= 0 x) (<= x 100))) + +(define-fun bool_eq7 ((x Int) (y Int)) Bool (ite (= x y) true false)) + +(declare-fun attr__ATTRIBUTE_IMAGE5 (Int) us_image) + +(declare-fun attr__ATTRIBUTE_VALUE__pre_check5 (us_image) Bool) + +(declare-fun attr__ATTRIBUTE_VALUE5 (us_image) Int) + +(declare-fun to_rep3 (nb_occ) Int) + +(declare-fun of_rep3 (Int) nb_occ) + +(declare-fun user_eq6 (nb_occ nb_occ) Bool) + +(declare-fun dummy6 () nb_occ) + +;; inversion_axiom + (assert + (forall ((x nb_occ)) + (! (= (of_rep3 (to_rep3 x)) x) :pattern ((to_rep3 x)) ))) + +;; range_axiom + (assert + (forall ((x nb_occ)) (! (in_range4 (to_rep3 x)) :pattern ((to_rep3 x)) +))) + +;; coerce_axiom + (assert + (forall ((x Int)) + (! (=> (in_range4 x) (= (to_rep3 (of_rep3 x)) x)) :pattern ((to_rep3 + (of_rep3 +x))) ))) + +(declare-datatypes () +((nb_occ__ref (mk_nb_occ__ref (nb_occ__content nb_occ))))) +(define-fun nb_occ__ref___projection ((a nb_occ__ref)) nb_occ +(nb_occ__content + a)) + +(define-fun dynamic_invariant3 ((temp___expr_155 Int) + (temp___is_init_152 Bool) (temp___do_constant_153 Bool) + (temp___do_toplevel_154 Bool)) Bool (=> + (or (= temp___is_init_152 true) + (<= 0 100)) (in_range4 + temp___expr_155))) + +(declare-fun occ_def (us_t Int) Int) + +;; occ__post_axiom + (assert + (forall ((a us_t)) + (forall ((e Int)) + (! (=> (and (dynamic_invariant2 a true true true) (in_range2 e)) + (let ((result (occ a e))) + (and (<= result (length a)) (dynamic_invariant3 result true false +true)))) :pattern ( + (occ a e)) )))) + +;; occ__def_axiom + (assert + (forall ((a us_t)) + (forall ((e Int)) + (! (=> (and (dynamic_invariant2 a true true true) (in_range2 e)) + (= (occ a e) (occ_def a e))) :pattern ((occ a e)) )))) + +(declare-fun is_set (us_t Int Int us_t) Bool) + +;; is_set__def_axiom + (assert + (forall ((a us_t) (r us_t)) + (forall ((i Int) (v Int)) + (! (= (= (is_set a i v r) true) + (and + (and (and (= (first1 r) (first1 a)) (= (last1 r) (last1 a))) + (= (to_rep1 (select (to_array r) i)) v)) + (forall ((j Int)) + (=> (and (<= (first1 a) j) (<= j (last1 a))) + (=> (not (= i j)) + (= (to_rep1 (select (to_array r) j)) (to_rep1 (select (to_array a) +j)))))))) :pattern ( + (is_set a i v r)) )))) + +(declare-fun a () us_t) + +(declare-fun attr__ATTRIBUTE_ADDRESS () Int) + +(declare-fun i () Int) + +(declare-fun attr__ATTRIBUTE_ADDRESS1 () Int) + +(declare-fun v () Int) + +(declare-fun attr__ATTRIBUTE_ADDRESS2 () Int) + +(declare-fun e () Int) + +(declare-fun attr__ATTRIBUTE_ADDRESS3 () Int) + +(declare-fun r () us_t) + +(declare-fun attr__ATTRIBUTE_ADDRESS4 () Int) + +(declare-fun b__first () integer) + +(declare-fun b__last () integer) + +(declare-fun attr__ATTRIBUTE_ADDRESS5 () Int) + +(define-fun dynamic_invariant4 ((temp___expr_15 Int) (temp___is_init_12 +Bool) + (temp___do_constant_13 Bool) + (temp___do_toplevel_14 Bool)) Bool (=> + (or (= temp___is_init_12 true) + (<= (- 2147483648) 2147483647)) + (in_range1 temp___expr_15))) + +;; occ_def__def_axiom + (assert + (forall ((a1 us_t)) + (forall ((e1 Int)) + (! (=> (and (dynamic_invariant2 a1 true true true) (in_range2 e1)) + (= (occ_def a1 e1) (ite (= (length a1) 0) 0 + (ite (= (to_rep1 (select (to_array a1) (last1 +a1))) e1) + (+ (occ_def (remove_last a1) e1) 1) + (occ_def (remove_last a1) e1))))) :pattern +((occ_def + a1 +e1)) )))) + +(declare-fun b () (Array Int natural)) + +(declare-fun perm__occ_set__b__assume () (Array Int natural)) + +(declare-fun perm__occ_set__b__assume1 () t) + +(declare-fun o () natural) + +(declare-fun o1 () Int) + +(declare-fun o2 () (Array Int natural)) + +(declare-fun o3 () (Array Int natural)) + +(declare-fun o4 () t) + +(declare-fun result () (Array Int natural)) + +(declare-fun b1 () (Array Int natural)) + +(declare-fun result1 () (Array Int natural)) + +(declare-fun b2 () (Array Int natural)) + +(define-fun o5 () us_t (mk___t o3 o4)) + +(define-fun perm__occ_set__b__assume2 () us_t (mk___t + perm__occ_set__b__assume + perm__occ_set__b__assume1)) + +;; H + (assert (dynamic_invariant2 a true false true)) + +;; H + (assert (in_range3 i)) + +;; H + (assert (in_range2 v)) + +;; H + (assert (in_range2 e)) + +;; H + (assert (dynamic_invariant2 r true false true)) + +;; H + (assert + (and (and (<= (to_rep (first (rt a))) i) (<= i (to_rep (last (rt a))))) + (= (is_set a i v r) true))) + +;; H + (assert + (and (= perm__occ_set__b__assume2 (remove_last a)) + (and (dynamic_invariant2 perm__occ_set__b__assume2 true false true) + (and (= (elts a) perm__occ_set__b__assume) + (= (mk + (to_rep + (first3 (mk1 (to_rep (first (rt a))) (- (to_rep (last (rt a))) 1)))) + (to_rep + (last3 (mk1 (to_rep (first (rt a))) (- (to_rep (last (rt a))) 1))))) + perm__occ_set__b__assume1))))) + +;; H + (assert (= (mk_map__ref result) (mk_map__ref b))) + +;; H + (assert (= b1 perm__occ_set__b__assume)) + +;; H + (assert (= (to_rep b__first) (to_rep (first +perm__occ_set__b__assume1)))) + +;; H + (assert (= (to_rep b__last) (to_rep (last perm__occ_set__b__assume1)))) + +;; H + (assert (dynamic_property 1 100 (to_rep b__first) (to_rep b__last))) + +;; H + (assert (not (= (length a) 0))) + +;; H + (assert (not (= i (to_rep (last (rt a)))))) + +;; H + (assert (= (to_rep1 o) v)) + +;; H + (assert (and (<= (to_rep b__first) i) (<= i (to_rep b__last)))) + +;; H + (assert (= o1 i)) + +;; H + (assert (= o2 (store b1 o1 o))) + +;; H + (assert (= b1 result1)) + +;; H + (assert (= b2 o2)) + +;; H + (assert + (and (= o5 (remove_last r)) + (and (dynamic_invariant2 o5 true false true) + (and (= (elts r) o3) + (= (mk + (to_rep + (first3 (mk1 (to_rep (first (rt r))) (- (to_rep (last (rt r))) 1)))) + (to_rep + (last3 (mk1 (to_rep (first (rt r))) (- (to_rep (last (rt r))) 1))))) + o4))))) + +(assert +;; WP_parameter_def + ;; File "perm.ads", line 21, characters 0-0 + (not + (= (bool_eq3 o3 (to_rep (first o4)) (to_rep (last o4)) b2 + (to_rep (first (mk (to_rep b__first) (to_rep b__last)))) + (to_rep (last (mk (to_rep b__first) (to_rep b__last))))) true))) +(check-sat) + diff --git a/test/regress/regress1/quantifiers/burns13.smt2 b/test/regress/regress1/quantifiers/burns13.smt2 new file mode 100644 index 000000000..3424c161e --- /dev/null +++ b/test/regress/regress1/quantifiers/burns13.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --full-saturate-quant --decision=internal +; EXPECT: unsat +(set-logic AUFLIA) +(set-info :source | Burns mutual exclusion protocol. This is a benchmark of the haRVey theorem prover. It was translated to SMT-LIB by Leonardo de Moura |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun s_0 (Int) Bool) +(declare-fun s_1 (Int) Bool) +(declare-fun s_2 (Int) Bool) +(declare-fun s_3 (Int) Bool) +(declare-fun s_4 (Int) Bool) +(declare-fun s_5 (Int) Bool) +(declare-fun s (Int Int) Bool) +(declare-fun flag (Int) Bool) +(declare-fun p () Int) +(declare-fun q () Int) +(assert (not (=> (and (forall ((?p Int)) (=> (not (flag ?p)) (or (s_0 ?p) (s_1 ?p) (s_2 ?p)))) (forall ((?p Int)) (forall ((?q Int)) (=> (s_2 ?p) (not (s ?p ?q))))) (forall ((?p Int)) (forall ((?q Int)) (=> (and (< ?q ?p) (flag ?q) (or (s_5 ?p) (s_4 ?p) (and (s_3 ?p) (s ?p ?q)))) (and (not (s_5 ?q)) (not (and (s_4 ?q) (s ?q ?p))))))) (forall ((?p Int)) (=> (s_0 ?p) (not (or (s_1 ?p) (s_2 ?p) (s_3 ?p) (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_1 ?p) (not (or (s_2 ?p) (s_3 ?p) (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_2 ?p) (not (or (s_3 ?p) (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_3 ?p) (not (or (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_4 ?p) (not (s_5 ?p)))) (forall ((?r Int)) (let ((?v_0 (not (= ?r p)))) (=> (s_0 ?r) (not (or (s_1 ?r) (s_2 ?r) (s_3 ?r) (=> ?v_0 (and ?v_0 (=> ?v_0 (s_4 ?r)))) (s_5 ?r)))))) (forall ((?r Int)) (let ((?v_1 (not (= ?r p)))) (=> (s_1 ?r) (not (or (s_2 ?r) (s_3 ?r) (=> ?v_1 (and ?v_1 (=> ?v_1 (s_4 ?r)))) (s_5 ?r)))))) (forall ((?r Int)) (let ((?v_2 (not (= ?r p)))) (=> (s_2 ?r) (not (or (s_3 ?r) (=> ?v_2 (and ?v_2 (=> ?v_2 (s_4 ?r)))) (s_5 ?r)))))) (forall ((?r Int)) (let ((?v_3 (not (= ?r p)))) (=> (s_3 ?r) (not (or (=> ?v_3 (and ?v_3 (=> ?v_3 (s_4 ?r)))) (s_5 ?r)))))) (forall ((?r Int)) (let ((?v_4 (not (= ?r p)))) (=> (=> ?v_4 (and ?v_4 (=> ?v_4 (s_4 ?r)))) (not (s_5 ?r))))) (s_4 p) (not (s p q)) (< p q) (not (flag q))) (and (forall ((?t Int)) (=> (not (flag ?t)) (or (s_0 ?t) (s_1 ?t) (s_2 ?t)))) (forall ((?t Int)) (forall ((?r Int)) (=> (s_2 ?t) (not (=> (not (and (= ?r q) (= ?t p))) (s ?t ?r)))))) (forall ((?t Int)) (forall ((?r Int)) (let ((?v_6 (= ?t p))) (let ((?v_5 (not ?v_6)) (?v_8 (= ?r p))) (let ((?v_7 (not ?v_8))) (=> (and (< ?r ?t) (flag ?r) (or (s_5 ?t) (=> ?v_5 (and ?v_5 (=> ?v_5 (s_4 ?t)))) (and (s_3 ?t) (=> (not (and (= ?r q) ?v_6)) (s ?t ?r))))) (and (not (s_5 ?r)) (not (and (=> ?v_7 (and ?v_7 (=> ?v_7 (s_4 ?r)))) (=> (not (and (= ?t q) ?v_8)) (s ?r ?t))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/burns4.smt2 b/test/regress/regress1/quantifiers/burns4.smt2 new file mode 100644 index 000000000..72023fd4f --- /dev/null +++ b/test/regress/regress1/quantifiers/burns4.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --full-saturate-quant +; EXPECT: unsat +(set-logic AUFLIA) +(set-info :source | Burns mutual exclusion protocol. This is a benchmark of the haRVey theorem prover. It was translated to SMT-LIB by Leonardo de Moura |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun s_0 (Int) Bool) +(declare-fun s_1 (Int) Bool) +(declare-fun s_2 (Int) Bool) +(declare-fun s_3 (Int) Bool) +(declare-fun s_4 (Int) Bool) +(declare-fun s_5 (Int) Bool) +(declare-fun s (Int Int) Bool) +(declare-fun flag (Int) Bool) +(declare-fun p () Int) +(declare-fun q () Int) +(assert (not (=> (and (forall ((?p Int)) (=> (not (flag ?p)) (or (s_0 ?p) (s_1 ?p) (s_2 ?p)))) (forall ((?p Int)) (forall ((?q Int)) (=> (s_2 ?p) (not (s ?p ?q))))) (forall ((?p Int)) (forall ((?q Int)) (=> (and (< ?q ?p) (flag ?q) (or (s_5 ?p) (s_4 ?p) (and (s_3 ?p) (s ?p ?q)))) (and (not (s_5 ?q)) (not (and (s_4 ?q) (s ?q ?p))))))) (forall ((?p Int)) (=> (s_0 ?p) (not (or (s_1 ?p) (s_2 ?p) (s_3 ?p) (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_1 ?p) (not (or (s_2 ?p) (s_3 ?p) (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_2 ?p) (not (or (s_3 ?p) (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_3 ?p) (not (or (s_4 ?p) (s_5 ?p))))) (forall ((?p Int)) (=> (s_4 ?p) (not (s_5 ?p))))) (forall ((?p Int)) (forall ((?q Int)) (=> (not (= ?p ?q)) (or (not (s_5 ?p)) (not (s_5 ?q))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/cbqi-sdlx-fixpoint-3-dd.smt2 b/test/regress/regress1/quantifiers/cbqi-sdlx-fixpoint-3-dd.smt2 new file mode 100644 index 000000000..4d5cf4ec4 --- /dev/null +++ b/test/regress/regress1/quantifiers/cbqi-sdlx-fixpoint-3-dd.smt2 @@ -0,0 +1,19 @@ +; COMMAND-LINE: --cbqi --decision=internal +; EXPECT: unsat +(set-logic LIA) +(set-info :status unsat) + +(assert (or +(forall ((H Int) (G Int)) (= (= G 0) (= H 0))) + +(forall ((C Int) (D Int) (E Int)) (or +(= (= D 0) (= C 0)) +(and +(not (forall ((G Int)) (= (= E 0) (= G 0)))) +(not (forall ((A Int)) + (not (= (ite (= A 0) 0 1) (ite (= C 0) 0 2))) +)) +))) +)) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/cdt-0208-to.smt2 b/test/regress/regress1/quantifiers/cdt-0208-to.smt2 new file mode 100644 index 000000000..9eff608bb --- /dev/null +++ b/test/regress/regress1/quantifiers/cdt-0208-to.smt2 @@ -0,0 +1,767 @@ +; COMMAND-LINE: --full-saturate-quant --lang=smt2.5 +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-sort A$ 0) +(declare-sort A_set$ 0) +(declare-sort A_a_fun$ 0) +(declare-sort A_bool_fun$ 0) +(declare-sort Bool_a_fun$ 0) +(declare-sort A_a_llist_fun$ 0) +(declare-sort A_llist_a_fun$ 0) +(declare-sort Bool_bool_fun$ 0) +(declare-sort A_a_bool_fun_fun$ 0) +(declare-sort A_llist_bool_fun$ 0) +(declare-sort Bool_a_llist_fun$ 0) +(declare-sort A_llist_a_set_fun$ 0) +(declare-sort A_a_llist_a_fun_fun$ 0) +(declare-sort A_llist_a_llist_fun$ 0) +(declare-sort A_a_llist_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_set$ 0) +(declare-sort A_a_llist_a_llist_fun_fun$ 0) +(declare-sort A_llist_a_llist_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_set_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_bool_fun$ 0) +(declare-sort Bool_a_llist_a_llist_prod_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_set_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_prod_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_fun$ 0) +(declare-sort A_llist_a_llist_prod_set_bool_fun$ 0) +(declare-sort Bool_a_llist_a_llist_prod_set_fun$ 0) +(declare-sort A_llist_a_llist_prod_llist_bool_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_prod_set_fun$ 0) +(declare-sort A_a_llist_a_fun_fun_a_llist_a_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_bool_fun_bool_fun$ 0) +(declare-sort Bool_a_llist_a_llist_prod_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_prod_bool_fun_fun$ 0) +(declare-sort A_a_llist_a_fun_fun_a_a_llist_a_fun_fun_fun$ 0) +(declare-sort A_a_llist_bool_fun_fun_a_llist_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_fun_a_llist_a_llist_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_fun$ 0) +(declare-sort A_a_llist_a_fun_fun_a_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_a_llist_bool_fun_fun_a_a_llist_a_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$ 0) +(declare-sort A_a_llist_a_fun_fun_a_a_llist_a_llist_fun_fun_fun$ 0) +(declare-sort A_a_llist_a_llist_fun_fun_a_a_llist_a_fun_fun_fun$ 0) +(declare-sort A_a_llist_a_llist_fun_fun_a_llist_a_llist_fun_fun$ 0) +(declare-sort A_a_llist_bool_fun_fun_a_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$ 0) +(declare-sort A_llist_a_llist_prod_set_a_llist_a_llist_prod_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$ 0) +(declare-sort A_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun$ 0) +(declare-sort A_a_llist_a_llist_fun_fun_a_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_a_llist_bool_fun_fun_a_a_llist_a_llist_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_fun_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$ 0) +(declare-sort A_a_llist_a_llist_fun_fun_a_a_llist_a_llist_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$ 0) +(declare-sort A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun$ 0) +(declare-sort A_llist_a_llist_prod_set_a_llist_a_llist_prod_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$ 0) +(declare-sort A_llist_a_fun_a_llist_a_llist_fun_a_llist_a_llist_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_bool_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun$ 0) +(declare-sort A_llist_a_llist_bool_fun_fun_a_llist_a_llist_prod_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod_set$ 0) +(declare-sort A_llist_a_llist_prod_bool_fun_a_llist_a_llist_prod_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_bool_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_set_a_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_set_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_bool_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_prod_set_fun_a_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_prod_set_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun_a_llist_a_llist_prod_llist_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ 0) +(declare-sort A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ 0) +(declare-codatatypes () ((A_llist$ (lNil$) (lCons$ (lhd$ A$) (ltl$ A_llist$))))) +(declare-datatypes () ((A_llist_a_llist_prod$ (pair$ (fst$ A_llist$) (snd$ A_llist$))))) +(declare-codatatypes () ((A_llist_a_llist_prod_llist$ (lNil$a) (lCons$a (lhd$a A_llist_a_llist_prod$) (ltl$a A_llist_a_llist_prod_llist$))))) +(declare-datatypes () ((A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod$ (pair$a (fst$a A_llist_a_llist_prod_llist$) (snd$a A_llist_a_llist_prod_llist$))) + (A_llist_a_llist_prod_a_llist_a_llist_prod_prod$ (pair$b (fst$b A_llist_a_llist_prod$) (snd$b A_llist_a_llist_prod$))))) +(declare-fun p$ () A_llist_a_llist_bool_fun_fun$) +(declare-fun uu$ (Bool) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun xs$ () A_llist$) +(declare-fun ys$ () A_llist$) +(declare-fun sup$ (A_llist_a_llist_prod_set$ A_llist_a_llist_prod_set$) A_llist_a_llist_prod_set$) +(declare-fun the$ (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod$) +(declare-fun uua$ (Bool) A_llist_a_llist_bool_fun_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uub$ (A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$) A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) +(declare-fun uuc$ (A_llist_a_llist_prod_a_llist_a_llist_prod_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uud$ (A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uue$ (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun uuf$ (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun uug$ (A_set$) A_bool_fun$) +(declare-fun uuh$ (A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) +(declare-fun uui$ (A_llist_a_llist_prod_set$) A_llist_a_llist_prod_bool_fun$) +(declare-fun uuj$ (Bool_bool_fun$) A_llist_a_llist_bool_fun_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uuk$ (Bool_a_llist_a_llist_prod_fun$ A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uul$ (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uum$ (Bool_a_llist_a_llist_prod_set_fun$) A_llist_a_llist_bool_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_fun$) +(declare-fun uun$ (A_llist_a_llist_prod_set_bool_fun$) A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uuo$ (Bool_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_bool_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$) +(declare-fun uup$ (Bool_bool_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun uuq$ (A_llist_a_llist_prod_bool_fun_bool_fun$) A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uur$ (A_llist_a_llist_prod_a_llist_a_llist_prod_fun$ A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uus$ (A_llist_a_llist_prod_set_a_llist_a_llist_prod_fun$ A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uut$ (A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun uuu$ (A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_fun$) +(declare-fun uuv$ (A_llist_a_llist_a_llist_a_llist_prod_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uuw$ (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uux$ (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun uuy$ (A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$) +(declare-fun uuz$ (A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uva$ () A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uvb$ () A_llist_a_llist_bool_fun_fun$) +(declare-fun uvc$ () A_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun$) +(declare-fun uvd$ () A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$) +(declare-fun uve$ () A_llist_a_fun$) +(declare-fun uvf$ () A_llist_a_llist_fun$) +(declare-fun uvg$ (A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uvh$ (Bool_bool_fun$) A_a_llist_bool_fun_fun_a_a_llist_bool_fun_fun_fun$) +(declare-fun uvi$ (Bool_a_llist_fun$) A_a_llist_bool_fun_fun_a_a_llist_a_llist_fun_fun_fun$) +(declare-fun uvj$ (Bool_a_fun$) A_a_llist_bool_fun_fun_a_a_llist_a_fun_fun_fun$) +(declare-fun uvk$ (A_llist_bool_fun$) A_a_llist_a_llist_fun_fun_a_a_llist_bool_fun_fun_fun$) +(declare-fun uvl$ (A_llist_a_llist_fun$) A_a_llist_a_llist_fun_fun_a_a_llist_a_llist_fun_fun_fun$) +(declare-fun uvm$ (A_llist_a_fun$) A_a_llist_a_llist_fun_fun_a_a_llist_a_fun_fun_fun$) +(declare-fun uvn$ (A_bool_fun$) A_a_llist_a_fun_fun_a_a_llist_bool_fun_fun_fun$) +(declare-fun uvo$ (A_a_llist_fun$) A_a_llist_a_fun_fun_a_a_llist_a_llist_fun_fun_fun$) +(declare-fun uvp$ (A_a_fun$) A_a_llist_a_fun_fun_a_a_llist_a_fun_fun_fun$) +(declare-fun uvq$ () A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$) +(declare-fun uvr$ () A_a_llist_bool_fun_fun$) +(declare-fun uvs$ () A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$) +(declare-fun uvt$ () A_a_llist_bool_fun_fun$) +(declare-fun uvu$ () A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun_fun$) +(declare-fun uvv$ () A_a_llist_a_llist_fun_fun$) +(declare-fun uvw$ () A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$) +(declare-fun uvx$ () A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uvy$ (A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uvz$ (A_llist_a_llist_prod_set$) A_llist_a_llist_bool_fun_fun$) +(declare-fun uwa$ () A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uwb$ () A_a_llist_a_fun_fun$) +(declare-fun uwc$ (A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) +(declare-fun uwd$ (A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) +(declare-fun uwe$ (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uwf$ (A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun uwg$ (A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun uwh$ (A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun_fun$) +(declare-fun uwi$ (A_llist$) A_a_llist_a_llist_fun_fun$) +(declare-fun uwj$ (A_llist$) A_a_llist_a_llist_fun_fun$) +(declare-fun uwk$ (A_llist_a_llist_prod_set$) A_llist_a_llist_fun_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun uwl$ (A_llist_bool_fun$) A_llist_a_llist_a_llist_prod_set_fun_a_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun_fun$) +(declare-fun uwm$ (A_llist_bool_fun$) A_llist_a_llist_a_llist_prod_set_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$) +(declare-fun uwn$ (A_llist_a_llist_prod_set$) A_llist_a_llist_prod_set_a_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun_fun$) +(declare-fun uwo$ (A_llist_a_llist_prod_set$) A_llist_a_llist_prod_set_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$) +(declare-fun uwp$ (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod_bool_fun_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uwq$ (A_llist_a_llist_prod_set$) A_llist_a_llist_prod_set_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uwr$ (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod_bool_fun_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uws$ (A_llist_a_llist_prod_set$) A_llist_a_llist_prod_bool_fun_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uwt$ (A_llist$) A_llist_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun lset$ (A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_set$) +(declare-fun swap$ (A_llist_a_llist_prod$) A_llist_a_llist_prod$) +(declare-fun lnull$ () A_llist_bool_fun$) +(declare-fun lset$a (A_llist$) A_set$) +(declare-fun swap$a (A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) +(declare-fun image2$ (A_llist_a_llist_prod_set$ A_llist_a_llist_prod_a_llist_fun$ A_llist_a_llist_prod_a_llist_fun$) A_llist_a_llist_prod_set$) +(declare-fun in_rel$ (A_llist_a_llist_prod_set$) A_llist_a_llist_bool_fun_fun$) +(declare-fun lnull$a () A_llist_a_llist_prod_llist_bool_fun$) +(declare-fun member$ (A_llist_a_llist_prod$) A_llist_a_llist_prod_set_bool_fun$) +(declare-fun collect$ (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod_set$) +(declare-fun fun_app$ (A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$ A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist$) +(declare-fun lappend$ (A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$) +(declare-fun less_eq$ (A_llist_a_llist_prod_set$) A_llist_a_llist_prod_set_bool_fun$) +(declare-fun lfinite$ (A_llist_a_llist_prod_llist$) Bool) +(declare-fun lmember$ (A_llist_a_llist_prod$) A_llist_a_llist_prod_llist_bool_fun$) +(declare-fun lprefix$ (A_llist$) A_llist_bool_fun$) +(declare-fun member$a (A_llist_a_llist_prod_a_llist_a_llist_prod_prod$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) Bool) +(declare-fun member$b (A$ A_set$) Bool) +(declare-fun member$c (A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod$ A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod_set$) Bool) +(declare-fun uncurry$ () A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$) +(declare-fun collect$a (A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) +(declare-fun collect$b (A_bool_fun$) A_set$) +(declare-fun fun_app$a (A_llist_a_llist_fun$ A_llist$) A_llist$) +(declare-fun fun_app$b (A_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun$ A_llist_a_llist_prod_llist$) A_llist_a_llist_prod$) +(declare-fun fun_app$c (A_llist_a_fun$ A_llist$) A$) +(declare-fun fun_app$d (A_llist_a_llist_a_llist_prod_fun$ A_llist$) A_llist_a_llist_prod$) +(declare-fun fun_app$e (A_llist_a_llist_a_llist_a_llist_prod_fun_fun$ A_llist$) A_llist_a_llist_a_llist_prod_fun$) +(declare-fun fun_app$f (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) +(declare-fun fun_app$g (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun$) +(declare-fun fun_app$h (A_llist_a_llist_prod_bool_fun$ A_llist_a_llist_prod$) Bool) +(declare-fun fun_app$i (A_llist_a_llist_prod_set_bool_fun$ A_llist_a_llist_prod_set$) Bool) +(declare-fun fun_app$j (A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) Bool) +(declare-fun fun_app$k (A_bool_fun$ A$) Bool) +(declare-fun fun_app$l (A_llist_bool_fun$ A_llist$) Bool) +(declare-fun fun_app$m (A_llist_a_llist_bool_fun_fun$ A_llist$) A_llist_bool_fun$) +(declare-fun fun_app$n (A_llist_a_llist_a_llist_prod_set_fun$ A_llist$) A_llist_a_llist_prod_set$) +(declare-fun fun_app$o (A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$ A_llist$) A_llist_a_llist_a_llist_prod_set_fun$) +(declare-fun fun_app$p (A_llist_a_llist_a_llist_prod_bool_fun_fun$ A_llist$) A_llist_a_llist_prod_bool_fun$) +(declare-fun fun_app$q (A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$ A_llist$) A_llist_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun fun_app$r (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_bool_fun$) +(declare-fun fun_app$s (A_llist_a_llist_prod_set_a_llist_a_llist_prod_bool_fun_fun$ A_llist_a_llist_prod_set$) A_llist_a_llist_prod_bool_fun$) +(declare-fun fun_app$t (A_llist_a_llist_prod_bool_fun_a_llist_a_llist_prod_bool_fun_fun$ A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod_bool_fun$) +(declare-fun fun_app$u (A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$) +(declare-fun fun_app$v (A_a_llist_a_llist_fun_fun$ A$) A_llist_a_llist_fun$) +(declare-fun fun_app$w (A_llist_a_llist_prod_a_llist_a_llist_prod_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod$) +(declare-fun fun_app$x (A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_set$) +(declare-fun fun_app$y (A_llist_a_llist_prod_a_llist_a_llist_bool_fun_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_bool_fun_fun$) +(declare-fun fun_app$z (A_llist_a_llist_fun_a_llist_a_llist_bool_fun_fun_fun$ A_llist_a_llist_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun lappend$a (A_llist$) A_llist_a_llist_fun$) +(declare-fun less_eq$a (A_set$ A_set$) Bool) +(declare-fun less_eq$b (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod_bool_fun_bool_fun$) +(declare-fun less_eq$c (A_llist_a_llist_bool_fun_fun$ A_llist_a_llist_bool_fun_fun$) Bool) +(declare-fun lex_prod$ (A_llist_a_llist_prod_set$ A_llist_a_llist_prod_set$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) +(declare-fun lfinite$a (A_llist$) Bool) +(declare-fun lmember$a (A$) A_llist_bool_fun$) +(declare-fun lprefix$a (A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist_bool_fun$) +(declare-fun same_fst$ (A_llist_bool_fun$ A_llist_a_llist_a_llist_prod_set_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) +(declare-fun uncurry$a () A_llist_a_llist_bool_fun_fun_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun uncurry$b () A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) +(declare-fun uncurry$c () A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun uncurry$d () A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun_fun$) +(declare-fun uncurry$e (A_llist_a_llist_a_set_fun_fun$ A_llist_a_llist_prod$) A_set$) +(declare-fun uncurry$f (A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) +(declare-fun uncurry$g (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) A_llist_a_llist_prod_set$) +(declare-fun uncurry$h (A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) A_set$) +(declare-fun uncurry$i (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) +(declare-fun uncurry$j (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) A_llist_a_llist_prod$) +(declare-fun uncurry$k (A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) +(declare-fun uncurry$l (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) +(declare-fun fun_app$aa (A_llist_a_llist_a_llist_bool_fun_fun_fun$ A_llist$) A_llist_a_llist_bool_fun_fun$) +(declare-fun fun_app$ab (A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_fun$) +(declare-fun fun_app$ac (A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun fun_app$ad (A_llist_a_llist_bool_fun_fun_a_llist_a_llist_prod_bool_fun_fun$ A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_prod_bool_fun$) +(declare-fun fun_app$ae (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun fun_app$af (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_fun$) +(declare-fun fun_app$ag (A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) +(declare-fun fun_app$ah (A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$) +(declare-fun fun_app$ai (A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun fun_app$aj (A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun fun_app$ak (A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun fun_app$al (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) +(declare-fun fun_app$am (A_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun$ A_llist$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) +(declare-fun fun_app$an (A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$ A_llist$) A_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun$) +(declare-fun fun_app$ao (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun fun_app$ap (A_llist_a_llist_bool_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun fun_app$aq (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) +(declare-fun fun_app$ar (A_a_llist_a_llist_fun_fun_a_a_llist_a_llist_fun_fun_fun$ A_a_llist_a_llist_fun_fun$) A_a_llist_a_llist_fun_fun$) +(declare-fun fun_app$as (A_a_llist_bool_fun_fun$ A$) A_llist_bool_fun$) +(declare-fun fun_app$at (A_a_llist_a_llist_fun_fun_a_a_llist_bool_fun_fun_fun$ A_a_llist_a_llist_fun_fun$) A_a_llist_bool_fun_fun$) +(declare-fun fun_app$au (A_a_llist_a_fun_fun$ A$) A_llist_a_fun$) +(declare-fun fun_app$av (A_a_llist_a_llist_fun_fun_a_a_llist_a_fun_fun_fun$ A_a_llist_a_llist_fun_fun$) A_a_llist_a_fun_fun$) +(declare-fun fun_app$aw (A_a_llist_bool_fun_fun_a_a_llist_a_llist_fun_fun_fun$ A_a_llist_bool_fun_fun$) A_a_llist_a_llist_fun_fun$) +(declare-fun fun_app$ax (Bool_a_llist_fun$ Bool) A_llist$) +(declare-fun fun_app$ay (Bool_a_llist_a_llist_prod_fun$ Bool) A_llist_a_llist_prod$) +(declare-fun fun_app$az (Bool_bool_fun$ Bool) Bool) +(declare-fun fun_app$ba (A_a_llist_bool_fun_fun_a_a_llist_bool_fun_fun_fun$ A_a_llist_bool_fun_fun$) A_a_llist_bool_fun_fun$) +(declare-fun fun_app$bb (A_llist_a_llist_bool_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_fun$ A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) +(declare-fun fun_app$bc (Bool_a_llist_a_llist_prod_set_fun$ Bool) A_llist_a_llist_prod_set$) +(declare-fun fun_app$bd (A_llist_a_llist_bool_fun_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ A_llist_a_llist_bool_fun_fun$) A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun fun_app$be (Bool_a_llist_a_llist_prod_bool_fun_fun$ Bool) A_llist_a_llist_prod_bool_fun$) +(declare-fun fun_app$bf (A_a_llist_bool_fun_fun_a_a_llist_a_fun_fun_fun$ A_a_llist_bool_fun_fun$) A_a_llist_a_fun_fun$) +(declare-fun fun_app$bg (Bool_a_fun$ Bool) A$) +(declare-fun fun_app$bh (A_llist_a_llist_prod_set_a_llist_a_llist_prod_fun$ A_llist_a_llist_prod_set$) A_llist_a_llist_prod$) +(declare-fun fun_app$bi (A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun fun_app$bj (A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_a_llist_a_llist_bool_fun_fun_fun$ A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun fun_app$bk (A_llist_a_llist_prod_bool_fun_bool_fun$ A_llist_a_llist_prod_bool_fun$) Bool) +(declare-fun fun_app$bl (A_a_llist_a_fun_fun_a_a_llist_a_llist_fun_fun_fun$ A_a_llist_a_fun_fun$) A_a_llist_a_llist_fun_fun$) +(declare-fun fun_app$bm (A_a_llist_fun$ A$) A_llist$) +(declare-fun fun_app$bn (A_a_llist_a_fun_fun_a_a_llist_bool_fun_fun_fun$ A_a_llist_a_fun_fun$) A_a_llist_bool_fun_fun$) +(declare-fun fun_app$bo (A_a_llist_a_fun_fun_a_a_llist_a_fun_fun_fun$ A_a_llist_a_fun_fun$) A_a_llist_a_fun_fun$) +(declare-fun fun_app$bp (A_a_fun$ A$) A$) +(declare-fun fun_app$bq (A_llist_a_llist_prod_set_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ A_llist_a_llist_prod_set$) A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun fun_app$br (A_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun$ A_llist$) A_llist_a_llist_a_llist_bool_fun_fun_fun$) +(declare-fun fun_app$bs (A_llist_a_llist_prod_set_a_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun_fun$ A_llist_a_llist_prod_set$) A_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun$) +(declare-fun fun_app$bt (A_llist_a_llist_a_llist_prod_set_fun_a_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_fun$ A_llist_a_llist_a_llist_prod_set_fun$) A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun fun_app$bu (A_llist_a_llist_a_llist_prod_set_fun_a_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun_fun$ A_llist_a_llist_a_llist_prod_set_fun$) A_llist_a_llist_a_llist_a_llist_bool_fun_fun_fun_fun$) +(declare-fun fun_app$bv (A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun$) +(declare-fun fun_app$bw (A_llist_a_llist_prod_llist_bool_fun$ A_llist_a_llist_prod_llist$) Bool) +(declare-fun fun_app$bx (A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_llist_bool_fun$) +(declare-fun fun_app$by (A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_bool_fun_fun$ A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist_bool_fun$) +(declare-fun fun_app$bz (A_llist_a_set_fun$ A_llist$) A_set$) +(declare-fun fun_app$ca (A_llist_a_llist_a_set_fun_fun$ A_llist$) A_llist_a_set_fun$) +(declare-fun fun_app$cb (A_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun$ A_llist$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) +(declare-fun fun_app$cc (A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$ A_llist$) A_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun$) +(declare-fun fun_app$cd (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$) +(declare-fun fun_app$ce (A_llist_a_llist_prod_a_set_fun$ A_llist_a_llist_prod$) A_set$) +(declare-fun fun_app$cf (A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_set_fun$) +(declare-fun fun_app$cg (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) +(declare-fun fun_app$ch (A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$ A_llist_a_llist_prod$) A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun$) +(declare-fun fun_app$ci (A_a_llist_bool_fun_fun_a_llist_bool_fun_fun$ A_a_llist_bool_fun_fun$) A_llist_bool_fun$) +(declare-fun fun_app$cj (A_a_llist_a_llist_fun_fun_a_llist_a_llist_fun_fun$ A_a_llist_a_llist_fun_fun$) A_llist_a_llist_fun$) +(declare-fun fun_app$ck (A_a_llist_a_fun_fun_a_llist_a_fun_fun$ A_a_llist_a_fun_fun$) A_llist_a_fun$) +(declare-fun fun_app$cl (A_llist_a_llist_fun_a_llist_a_llist_fun_fun$ A_llist_a_llist_fun$) A_llist_a_llist_fun$) +(declare-fun fun_app$cm (A_llist_a_fun_a_llist_a_llist_fun_a_llist_a_llist_fun_fun_fun$ A_llist_a_fun$) A_llist_a_llist_fun_a_llist_a_llist_fun_fun$) +(declare-fun fun_app$cn (A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun_a_llist_a_llist_prod_llist_bool_fun_fun$ A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$) A_llist_a_llist_prod_llist_bool_fun$) +(declare-fun fun_app$co (A_a_bool_fun_fun$ A$) A_bool_fun$) +(declare-fun fun_app$cp (A_llist_a_llist_prod_a_llist_fun$ A_llist_a_llist_prod$) A_llist$) +(declare-fun inv_image$ (A_llist_a_llist_prod_set$ A_llist_a_llist_fun$) A_llist_a_llist_prod_set$) +(declare-fun undefined$ () A_llist$) +(declare-fun case_llist$ (Bool) A_a_llist_bool_fun_fun_a_llist_bool_fun_fun$) +(declare-fun llist_all2$ (A_a_bool_fun_fun$) A_llist_a_llist_bool_fun_fun$) +(declare-fun pred_llist$ (A_bool_fun$) A_llist_bool_fun$) +(declare-fun undefined$a () A$) +(declare-fun case_llist$a (A_llist$) A_a_llist_a_llist_fun_fun_a_llist_a_llist_fun_fun$) +(declare-fun case_llist$b (A$) A_a_llist_a_fun_fun_a_llist_a_fun_fun$) +(declare-fun case_llist$c (Bool) A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun_a_llist_a_llist_prod_llist_bool_fun_fun$) +(declare-fun case_llist$d (A_llist_a_llist_prod_llist$ A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun_fun$ A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist$) +(declare-fun case_llist$e (A_llist_a_llist_prod$ A_llist_a_llist_prod_a_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun_fun$ A_llist_a_llist_prod_llist$) A_llist_a_llist_prod$) +(declare-fun llist_all2$a (A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_bool_fun_fun$) +(declare-fun pred_llist$a (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod_llist_bool_fun$) +(declare-fun unfold_llist$ (A_llist_a_llist_prod_llist_bool_fun$ A_llist_a_llist_prod_llist_a_llist_a_llist_prod_fun$ A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$ A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist$) +(declare-fun unfold_llist$a (A_llist_bool_fun$) A_llist_a_fun_a_llist_a_llist_fun_a_llist_a_llist_fun_fun_fun$) +(declare-fun internal_split$ () A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) +(declare-fun internal_split$a () A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$) +(declare-fun internal_split$b () A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun_fun$) +(declare-fun internal_split$c () A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun_fun$) +(declare-fun internal_split$d () A_llist_a_llist_bool_fun_fun_a_llist_a_llist_prod_bool_fun_fun$) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ uvd$ ?v0) (ltl$a ?v0)) :pattern ((fun_app$ uvd$ ?v0)))) :named a0)) +(assert (! (forall ((?v0 A_llist$)) (! (= (fun_app$a uvf$ ?v0) (ltl$ ?v0)) :pattern ((fun_app$a uvf$ ?v0)))) :named a1)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (! (= (fun_app$b uvc$ ?v0) (lhd$a ?v0)) :pattern ((fun_app$b uvc$ ?v0)))) :named a2)) +(assert (! (forall ((?v0 A_llist$)) (! (= (fun_app$c uve$ ?v0) (lhd$ ?v0)) :pattern ((fun_app$c uve$ ?v0)))) :named a3)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (! (= (fun_app$d (fun_app$e uvx$ ?v0) ?v1) (pair$ ?v0 ?v1)) :pattern ((fun_app$d (fun_app$e uvx$ ?v0) ?v1)))) :named a4)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$)) (! (= (fun_app$f (fun_app$g uvw$ ?v0) ?v1) (pair$b ?v0 ?v1)) :pattern ((fun_app$f (fun_app$g uvw$ ?v0) ?v1)))) :named a5)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod$)) (! (= (fun_app$h (uui$ ?v0) ?v1) (fun_app$i (member$ ?v1) ?v0)) :pattern ((fun_app$h (uui$ ?v0) ?v1)))) :named a6)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (! (= (fun_app$j (uuh$ ?v0) ?v1) (member$a ?v1 ?v0)) :pattern ((fun_app$j (uuh$ ?v0) ?v1)))) :named a7)) +(assert (! (forall ((?v0 A_set$) (?v1 A$)) (! (= (fun_app$k (uug$ ?v0) ?v1) (member$b ?v1 ?v0)) :pattern ((fun_app$k (uug$ ?v0) ?v1)))) :named a8)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$d (fun_app$e (uwd$ ?v0) ?v1) ?v2) (fun_app$d (fun_app$e ?v0 ?v2) ?v1)) :pattern ((fun_app$d (fun_app$e (uwd$ ?v0) ?v1) ?v2)))) :named a9)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (uwg$ ?v0) ?v1) ?v2) (fun_app$l (fun_app$m ?v0 ?v2) ?v1)) :pattern ((fun_app$l (fun_app$m (uwg$ ?v0) ?v1) ?v2)))) :named a10)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$n (fun_app$o (uwc$ ?v0) ?v1) ?v2) (fun_app$n (fun_app$o ?v0 ?v2) ?v1)) :pattern ((fun_app$n (fun_app$o (uwc$ ?v0) ?v1) ?v2)))) :named a11)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$p (fun_app$q (uwf$ ?v0) ?v1) ?v2) (fun_app$p (fun_app$q ?v0 ?v2) ?v1)) :pattern ((fun_app$p (fun_app$q (uwf$ ?v0) ?v1) ?v2)))) :named a12)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (uwe$ ?v0) ?v1) ?v2) (fun_app$h (fun_app$r ?v0 ?v2) ?v1)) :pattern ((fun_app$h (fun_app$r (uwe$ ?v0) ?v1) ?v2)))) :named a13)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$s (uwq$ ?v0) ?v1) ?v2) (or (fun_app$i (member$ ?v2) ?v0) (fun_app$i (member$ ?v2) ?v1))) :pattern ((fun_app$h (fun_app$s (uwq$ ?v0) ?v1) ?v2)))) :named a14)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$t (uws$ ?v0) ?v1) ?v2) (and (fun_app$i (member$ ?v2) ?v0) (fun_app$h ?v1 ?v2))) :pattern ((fun_app$h (fun_app$t (uws$ ?v0) ?v1) ?v2)))) :named a15)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (uvz$ ?v0) ?v1) ?v2) (fun_app$i (member$ (pair$ ?v1 ?v2)) ?v0)) :pattern ((fun_app$l (fun_app$m (uvz$ ?v0) ?v1) ?v2)))) :named a16)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (uvy$ ?v0) ?v1) ?v2) (member$a (pair$b ?v1 ?v2) ?v0)) :pattern ((fun_app$h (fun_app$r (uvy$ ?v0) ?v1) ?v2)))) :named a17)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$t (uwp$ ?v0) ?v1) ?v2) (or (fun_app$h ?v0 ?v2) (fun_app$h ?v1 ?v2))) :pattern ((fun_app$h (fun_app$t (uwp$ ?v0) ?v1) ?v2)))) :named a18)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$t (uwr$ ?v0) ?v1) ?v2) (and (fun_app$h ?v0 ?v2) (fun_app$h ?v1 ?v2))) :pattern ((fun_app$h (fun_app$t (uwr$ ?v0) ?v1) ?v2)))) :named a19)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ (fun_app$u (uwh$ ?v0) ?v1) ?v2) (lCons$a ?v1 (fun_app$ (lappend$ ?v2) ?v0))) :pattern ((fun_app$ (fun_app$u (uwh$ ?v0) ?v1) ?v2)))) :named a20)) +(assert (! (forall ((?v0 A_llist$) (?v1 A$) (?v2 A_llist$)) (! (= (fun_app$a (fun_app$v (uwi$ ?v0) ?v1) ?v2) (lCons$ ?v1 (fun_app$a (lappend$a ?v2) ?v0))) :pattern ((fun_app$a (fun_app$v (uwi$ ?v0) ?v1) ?v2)))) :named a21)) +(assert (! (forall ((?v0 A_llist$) (?v1 A$) (?v2 A_llist$)) (! (= (fun_app$a (fun_app$v (uwj$ ?v0) ?v1) ?v2) (fun_app$a (lappend$a ?v2) ?v0)) :pattern ((fun_app$a (fun_app$v (uwj$ ?v0) ?v1) ?v2)))) :named a22)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$d (fun_app$e (uuc$ ?v0) ?v1) ?v2) (fun_app$w ?v0 (pair$ ?v1 ?v2))) :pattern ((fun_app$d (fun_app$e (uuc$ ?v0) ?v1) ?v2)))) :named a23)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (uuf$ ?v0) ?v1) ?v2) (fun_app$h ?v0 (pair$ ?v1 ?v2))) :pattern ((fun_app$l (fun_app$m (uuf$ ?v0) ?v1) ?v2)))) :named a24)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$n (fun_app$o (uub$ ?v0) ?v1) ?v2) (fun_app$x ?v0 (pair$ ?v1 ?v2))) :pattern ((fun_app$n (fun_app$o (uub$ ?v0) ?v1) ?v2)))) :named a25)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$p (fun_app$q (uue$ ?v0) ?v1) ?v2) (fun_app$r ?v0 (pair$ ?v1 ?v2))) :pattern ((fun_app$p (fun_app$q (uue$ ?v0) ?v1) ?v2)))) :named a26)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (uud$ ?v0) ?v1) ?v2) (fun_app$j ?v0 (pair$b ?v1 ?v2))) :pattern ((fun_app$h (fun_app$r (uud$ ?v0) ?v1) ?v2)))) :named a27)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$y (uvg$ ?v0) ?v1) ?v2) ?v3) (fun_app$h (fun_app$p (fun_app$q ?v0 ?v2) ?v3) ?v1)) :pattern ((fun_app$l (fun_app$m (fun_app$y (uvg$ ?v0) ?v1) ?v2) ?v3)))) :named a28)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$z (uwk$ ?v0) ?v1) ?v2) ?v3) (fun_app$i (member$ (pair$ (fun_app$a ?v1 ?v2) (fun_app$a ?v1 ?v3))) ?v0)) :pattern ((fun_app$l (fun_app$m (fun_app$z (uwk$ ?v0) ?v1) ?v2) ?v3)))) :named a29)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (uwt$ ?v0) ?v1) ?v2) ?v3) (and (= ?v0 ?v2) (= ?v1 ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (uwt$ ?v0) ?v1) ?v2) ?v3)))) :named a30)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$d (fun_app$e (uuv$ ?v0 ?v1) ?v2) ?v3) (fun_app$w (fun_app$ab uncurry$ ?v0) (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$d (fun_app$e (uuv$ ?v0 ?v1) ?v2) ?v3)))) :named a31)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$ac (uuz$ ?v0) ?v1) ?v2) ?v3) (fun_app$h (fun_app$ad uncurry$a ?v0) (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$ac (uuz$ ?v0) ?v1) ?v2) ?v3)))) :named a32)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (fun_app$ae (uut$ ?v0) ?v1) ?v2) ?v3) (fun_app$h (fun_app$ad uncurry$a ?v0) (fun_app$w (fun_app$af ?v1 ?v2) ?v3))) :pattern ((fun_app$h (fun_app$r (fun_app$ae (uut$ ?v0) ?v1) ?v2) ?v3)))) :named a33)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$n (fun_app$o (fun_app$ag (uuu$ ?v0) ?v1) ?v2) ?v3) (fun_app$x (fun_app$ah uncurry$b ?v0) (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$n (fun_app$o (fun_app$ag (uuu$ ?v0) ?v1) ?v2) ?v3)))) :named a34)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$p (fun_app$q (fun_app$ai (uuy$ ?v0) ?v1) ?v2) ?v3) (fun_app$r (fun_app$aj uncurry$c ?v0) (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$p (fun_app$q (fun_app$ai (uuy$ ?v0) ?v1) ?v2) ?v3)))) :named a35)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$ak (uuw$ ?v0) ?v1) ?v2) ?v3) (fun_app$j (fun_app$al uncurry$d ?v0) (fun_app$am (fun_app$an ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$ak (uuw$ ?v0) ?v1) ?v2) ?v3)))) :named a36)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (fun_app$ao (uux$ ?v0) ?v1) ?v2) ?v3) (fun_app$j (fun_app$al uncurry$d ?v0) (fun_app$f (fun_app$g ?v1 ?v2) ?v3))) :pattern ((fun_app$h (fun_app$r (fun_app$ao (uux$ ?v0) ?v1) ?v2) ?v3)))) :named a37)) +(assert (! (forall ((?v0 Bool) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$ap (uua$ ?v0) ?v1) ?v2) ?v3) (and ?v0 (fun_app$l (fun_app$m ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$ap (uua$ ?v0) ?v1) ?v2) ?v3)))) :named a38)) +(assert (! (forall ((?v0 Bool) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (fun_app$aq (uu$ ?v0) ?v1) ?v2) ?v3) (and ?v0 (fun_app$h (fun_app$r ?v1 ?v2) ?v3))) :pattern ((fun_app$h (fun_app$r (fun_app$aq (uu$ ?v0) ?v1) ?v2) ?v3)))) :named a39)) +(assert (! (forall ((?v0 A_llist_a_llist_fun$) (?v1 A_a_llist_a_llist_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$a (fun_app$v (fun_app$ar (uvl$ ?v0) ?v1) ?v2) ?v3) (fun_app$a ?v0 (fun_app$a (fun_app$v ?v1 ?v2) ?v3))) :pattern ((fun_app$a (fun_app$v (fun_app$ar (uvl$ ?v0) ?v1) ?v2) ?v3)))) :named a40)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_a_llist_a_llist_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$as (fun_app$at (uvk$ ?v0) ?v1) ?v2) ?v3) (fun_app$l ?v0 (fun_app$a (fun_app$v ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$as (fun_app$at (uvk$ ?v0) ?v1) ?v2) ?v3)))) :named a41)) +(assert (! (forall ((?v0 A_llist_a_fun$) (?v1 A_a_llist_a_llist_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$c (fun_app$au (fun_app$av (uvm$ ?v0) ?v1) ?v2) ?v3) (fun_app$c ?v0 (fun_app$a (fun_app$v ?v1 ?v2) ?v3))) :pattern ((fun_app$c (fun_app$au (fun_app$av (uvm$ ?v0) ?v1) ?v2) ?v3)))) :named a42)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$d (fun_app$e (uur$ ?v0 ?v1) ?v2) ?v3) (fun_app$w ?v0 (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$d (fun_app$e (uur$ ?v0 ?v1) ?v2) ?v3)))) :named a43)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$ac (uul$ ?v0) ?v1) ?v2) ?v3) (fun_app$h ?v0 (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$ac (uul$ ?v0) ?v1) ?v2) ?v3)))) :named a44)) +(assert (! (forall ((?v0 Bool_a_llist_fun$) (?v1 A_a_llist_bool_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$a (fun_app$v (fun_app$aw (uvi$ ?v0) ?v1) ?v2) ?v3) (fun_app$ax ?v0 (fun_app$l (fun_app$as ?v1 ?v2) ?v3))) :pattern ((fun_app$a (fun_app$v (fun_app$aw (uvi$ ?v0) ?v1) ?v2) ?v3)))) :named a45)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$d (fun_app$e (uuk$ ?v0 ?v1) ?v2) ?v3) (fun_app$ay ?v0 (fun_app$l (fun_app$m ?v1 ?v2) ?v3))) :pattern ((fun_app$d (fun_app$e (uuk$ ?v0 ?v1) ?v2) ?v3)))) :named a46)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$ap (uuj$ ?v0) ?v1) ?v2) ?v3) (fun_app$az ?v0 (fun_app$l (fun_app$m ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$ap (uuj$ ?v0) ?v1) ?v2) ?v3)))) :named a47)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (fun_app$aq (uup$ ?v0) ?v1) ?v2) ?v3) (fun_app$az ?v0 (fun_app$h (fun_app$r ?v1 ?v2) ?v3))) :pattern ((fun_app$h (fun_app$r (fun_app$aq (uup$ ?v0) ?v1) ?v2) ?v3)))) :named a48)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_a_llist_bool_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$as (fun_app$ba (uvh$ ?v0) ?v1) ?v2) ?v3) (fun_app$az ?v0 (fun_app$l (fun_app$as ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$as (fun_app$ba (uvh$ ?v0) ?v1) ?v2) ?v3)))) :named a49)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_set_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$n (fun_app$o (fun_app$bb (uum$ ?v0) ?v1) ?v2) ?v3) (fun_app$bc ?v0 (fun_app$l (fun_app$m ?v1 ?v2) ?v3))) :pattern ((fun_app$n (fun_app$o (fun_app$bb (uum$ ?v0) ?v1) ?v2) ?v3)))) :named a50)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$p (fun_app$q (fun_app$bd (uuo$ ?v0) ?v1) ?v2) ?v3) (fun_app$be ?v0 (fun_app$l (fun_app$m ?v1 ?v2) ?v3))) :pattern ((fun_app$p (fun_app$q (fun_app$bd (uuo$ ?v0) ?v1) ?v2) ?v3)))) :named a51)) +(assert (! (forall ((?v0 Bool_a_fun$) (?v1 A_a_llist_bool_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$c (fun_app$au (fun_app$bf (uvj$ ?v0) ?v1) ?v2) ?v3) (fun_app$bg ?v0 (fun_app$l (fun_app$as ?v1 ?v2) ?v3))) :pattern ((fun_app$c (fun_app$au (fun_app$bf (uvj$ ?v0) ?v1) ?v2) ?v3)))) :named a52)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$d (fun_app$e (uus$ ?v0 ?v1) ?v2) ?v3) (fun_app$bh ?v0 (fun_app$n (fun_app$o ?v1 ?v2) ?v3))) :pattern ((fun_app$d (fun_app$e (uus$ ?v0 ?v1) ?v2) ?v3)))) :named a53)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$bi (uun$ ?v0) ?v1) ?v2) ?v3) (fun_app$i ?v0 (fun_app$n (fun_app$o ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$bi (uun$ ?v0) ?v1) ?v2) ?v3)))) :named a54)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$bj (uuq$ ?v0) ?v1) ?v2) ?v3) (fun_app$bk ?v0 (fun_app$p (fun_app$q ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$bj (uuq$ ?v0) ?v1) ?v2) ?v3)))) :named a55)) +(assert (! (forall ((?v0 A_a_llist_fun$) (?v1 A_a_llist_a_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$a (fun_app$v (fun_app$bl (uvo$ ?v0) ?v1) ?v2) ?v3) (fun_app$bm ?v0 (fun_app$c (fun_app$au ?v1 ?v2) ?v3))) :pattern ((fun_app$a (fun_app$v (fun_app$bl (uvo$ ?v0) ?v1) ?v2) ?v3)))) :named a56)) +(assert (! (forall ((?v0 A_bool_fun$) (?v1 A_a_llist_a_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$as (fun_app$bn (uvn$ ?v0) ?v1) ?v2) ?v3) (fun_app$k ?v0 (fun_app$c (fun_app$au ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$as (fun_app$bn (uvn$ ?v0) ?v1) ?v2) ?v3)))) :named a57)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A_a_llist_a_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$c (fun_app$au (fun_app$bo (uvp$ ?v0) ?v1) ?v2) ?v3) (fun_app$bp ?v0 (fun_app$c (fun_app$au ?v1 ?v2) ?v3))) :pattern ((fun_app$c (fun_app$au (fun_app$bo (uvp$ ?v0) ?v1) ?v2) ?v3)))) :named a58)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$p (fun_app$q (fun_app$bq (uwo$ ?v0) ?v1) ?v2) ?v3) (fun_app$ad uncurry$a (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3))) :pattern ((fun_app$p (fun_app$q (fun_app$bq (uwo$ ?v0) ?v1) ?v2) ?v3)))) :named a59)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_llist_a_llist_prod_set_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$p (fun_app$q (fun_app$bt (uwm$ ?v0) ?v1) ?v2) ?v3) (fun_app$ad uncurry$a (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3))) :pattern ((fun_app$p (fun_app$q (fun_app$bt (uwm$ ?v0) ?v1) ?v2) ?v3)))) :named a60)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist$) (?v5 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) (or (fun_app$i (member$ (pair$ ?v2 ?v4)) ?v0) (and (= ?v2 ?v4) (fun_app$i (member$ (pair$ ?v3 ?v5)) ?v1)))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5)))) :named a61)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_llist_a_llist_prod_set_fun$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist$) (?v5 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) (and (= ?v2 ?v4) (and (fun_app$l ?v0 ?v4) (fun_app$i (member$ (pair$ ?v3 ?v5)) (fun_app$n ?v1 ?v4))))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5)))) :named a62)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (fun_app$b (fun_app$bv uwa$ ?v0) ?v1) ?v0) :pattern ((fun_app$b (fun_app$bv uwa$ ?v0) ?v1)))) :named a63)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (fun_app$c (fun_app$au uwb$ ?v0) ?v1) ?v0) :pattern ((fun_app$c (fun_app$au uwb$ ?v0) ?v1)))) :named a64)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ (fun_app$u uvu$ ?v0) ?v1) ?v1) :pattern ((fun_app$ (fun_app$u uvu$ ?v0) ?v1)))) :named a65)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (fun_app$a (fun_app$v uvv$ ?v0) ?v1) ?v1) :pattern ((fun_app$a (fun_app$v uvv$ ?v0) ?v1)))) :named a66)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (fun_app$bw (fun_app$bx uvs$ ?v0) ?v1) false) :pattern ((fun_app$bw (fun_app$bx uvs$ ?v0) ?v1)))) :named a67)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (fun_app$l (fun_app$as uvt$ ?v0) ?v1) false) :pattern ((fun_app$l (fun_app$as uvt$ ?v0) ?v1)))) :named a68)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (! (= (fun_app$l (fun_app$m uvb$ ?v0) ?v1) true) :pattern ((fun_app$l (fun_app$m uvb$ ?v0) ?v1)))) :named a69)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (fun_app$bw (fun_app$bx uvq$ ?v0) ?v1) true) :pattern ((fun_app$bw (fun_app$bx uvq$ ?v0) ?v1)))) :named a70)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r uva$ ?v0) ?v1) true) :pattern ((fun_app$h (fun_app$r uva$ ?v0) ?v1)))) :named a71)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (fun_app$l (fun_app$as uvr$ ?v0) ?v1) true) :pattern ((fun_app$l (fun_app$as uvr$ ?v0) ?v1)))) :named a72)) +(assert (! (not (fun_app$l (lprefix$ xs$) ys$)) :named a73)) +(assert (! (fun_app$l (fun_app$m p$ xs$) ys$) :named a74)) +(assert (! (fun_app$i (member$ (pair$ xs$ ys$)) (collect$ (fun_app$ad uncurry$a p$))) :named a75)) +(assert (! (forall ((?v0 A_llist$)) (fun_app$l (lprefix$ lNil$) ?v0)) :named a76)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$bw (lprefix$a ?v0) ?v1) (fun_app$bw (lprefix$a (lCons$a ?v2 ?v0)) (lCons$a ?v2 ?v1)))) :named a77)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A$)) (=> (fun_app$l (lprefix$ ?v0) ?v1) (fun_app$l (lprefix$ (lCons$ ?v2 ?v0)) (lCons$ ?v2 ?v1)))) :named a78)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (fun_app$l (fun_app$m p$ ?v0) ?v1) (and (=> (fun_app$l lnull$ ?v1) (fun_app$l lnull$ ?v0)) (=> (and (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) (and (= (lhd$ ?v0) (lhd$ ?v1)) (or (fun_app$l (fun_app$m p$ (ltl$ ?v0)) (ltl$ ?v1)) (fun_app$l (lprefix$ (ltl$ ?v0)) (ltl$ ?v1)))))))) :named a79)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (fun_app$bw (lprefix$a ?v0) ?v1) (or (exists ((?v2 A_llist_a_llist_prod_llist$)) (and (= ?v0 lNil$a) (= ?v1 ?v2))) (exists ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod$)) (and (= ?v0 (lCons$a ?v4 ?v2)) (and (= ?v1 (lCons$a ?v4 ?v3)) (fun_app$bw (lprefix$a ?v2) ?v3))))))) :named a80)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (fun_app$l (lprefix$ ?v0) ?v1) (or (exists ((?v2 A_llist$)) (and (= ?v0 lNil$) (= ?v1 ?v2))) (exists ((?v2 A_llist$) (?v3 A_llist$) (?v4 A$)) (and (= ?v0 (lCons$ ?v4 ?v2)) (and (= ?v1 (lCons$ ?v4 ?v3)) (fun_app$l (lprefix$ ?v2) ?v3))))))) :named a81)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$bw (lprefix$a ?v0) ?v1) (and (forall ((?v2 A_llist_a_llist_prod_llist$)) (=> (and (= ?v0 lNil$a) (= ?v1 ?v2)) false)) (forall ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v0 (lCons$a ?v4 ?v2)) (and (= ?v1 (lCons$a ?v4 ?v3)) (fun_app$bw (lprefix$a ?v2) ?v3))) false)))) false)) :named a82)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (and (fun_app$l (lprefix$ ?v0) ?v1) (and (forall ((?v2 A_llist$)) (=> (and (= ?v0 lNil$) (= ?v1 ?v2)) false)) (forall ((?v2 A_llist$) (?v3 A_llist$) (?v4 A$)) (=> (and (= ?v0 (lCons$ ?v4 ?v2)) (and (= ?v1 (lCons$ ?v4 ?v3)) (fun_app$l (lprefix$ ?v2) ?v3))) false)))) false)) :named a83)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$bw (fun_app$by ?v0 ?v1) ?v2) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod_llist$)) (=> (fun_app$bw (fun_app$by ?v0 ?v3) ?v4) (or (exists ((?v5 A_llist_a_llist_prod_llist$)) (and (= ?v3 lNil$a) (= ?v4 ?v5))) (exists ((?v5 A_llist_a_llist_prod_llist$) (?v6 A_llist_a_llist_prod_llist$) (?v7 A_llist_a_llist_prod$)) (and (= ?v3 (lCons$a ?v7 ?v5)) (and (= ?v4 (lCons$a ?v7 ?v6)) (or (fun_app$bw (fun_app$by ?v0 ?v5) ?v6) (fun_app$bw (lprefix$a ?v5) ?v6))))))))) (fun_app$bw (lprefix$a ?v1) ?v2))) :named a84)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (=> (and (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v3) ?v4) (or (exists ((?v5 A_llist$)) (and (= ?v3 lNil$) (= ?v4 ?v5))) (exists ((?v5 A_llist$) (?v6 A_llist$) (?v7 A$)) (and (= ?v3 (lCons$ ?v7 ?v5)) (and (= ?v4 (lCons$ ?v7 ?v6)) (or (fun_app$l (fun_app$m ?v0 ?v5) ?v6) (fun_app$l (lprefix$ ?v5) ?v6))))))))) (fun_app$l (lprefix$ ?v1) ?v2))) :named a85)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod_set$)) (=> (and (member$c (pair$a ?v0 ?v1) ?v2) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod_llist$)) (=> (member$c (pair$a ?v3 ?v4) ?v2) (or (fun_app$bw lnull$a ?v3) (exists ((?v5 A_llist_a_llist_prod$) (?v6 A_llist_a_llist_prod_llist$) (?v7 A_llist_a_llist_prod_llist$)) (and (= ?v3 (lCons$a ?v5 ?v6)) (and (= ?v4 (lCons$a ?v5 ?v7)) (or (member$c (pair$a ?v6 ?v7) ?v2) (fun_app$bw (lprefix$a ?v6) ?v7))))))))) (fun_app$bw (lprefix$a ?v0) ?v1))) :named a86)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$)) (=> (and (fun_app$i (member$ (pair$ ?v0 ?v1)) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (fun_app$i (member$ (pair$ ?v3 ?v4)) ?v2) (or (fun_app$l lnull$ ?v3) (exists ((?v5 A$) (?v6 A_llist$) (?v7 A_llist$)) (and (= ?v3 (lCons$ ?v5 ?v6)) (and (= ?v4 (lCons$ ?v5 ?v7)) (or (fun_app$i (member$ (pair$ ?v6 ?v7)) ?v2) (fun_app$l (lprefix$ ?v6) ?v7))))))))) (fun_app$l (lprefix$ ?v0) ?v1))) :named a87)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$) (?v2 A$) (?v3 A_llist$)) (= (= (lCons$ ?v0 ?v1) (lCons$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a88)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (= (= (lCons$a ?v0 ?v1) (lCons$a ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a89)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v0)) (= (lCons$a (lhd$a ?v0) (ltl$a ?v0)) ?v0))) :named a90)) +(assert (! (forall ((?v0 A_llist$)) (=> (not (fun_app$l lnull$ ?v0)) (= (lCons$ (lhd$ ?v0) (ltl$ ?v0)) ?v0))) :named a91)) +(assert (! (forall ((?v0 A_llist$)) (= (not (= ?v0 lNil$)) (exists ((?v1 A$) (?v2 A_llist$)) (= ?v0 (lCons$ ?v1 ?v2))))) :named a92)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (= (not (= ?v0 lNil$a)) (exists ((?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (= ?v0 (lCons$a ?v1 ?v2))))) :named a93)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (= (not (fun_app$bw lnull$a ?v0)) (exists ((?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (= ?v0 (lCons$a ?v1 ?v2))))) :named a94)) +(assert (! (forall ((?v0 A_llist$)) (= (not (fun_app$l lnull$ ?v0)) (exists ((?v1 A$) (?v2 A_llist$)) (= ?v0 (lCons$ ?v1 ?v2))))) :named a95)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (! (= (fun_app$bw lnull$a ?v0) (= ?v0 lNil$a)) :pattern ((fun_app$bw lnull$a ?v0)))) :named a96)) +(assert (! (forall ((?v0 A_llist$)) (! (= (fun_app$l lnull$ ?v0) (= ?v0 lNil$)) :pattern ((fun_app$l lnull$ ?v0)))) :named a97)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (lhd$a (lCons$a ?v0 ?v1)) ?v0) :pattern ((lCons$a ?v0 ?v1)))) :named a98)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (lhd$ (lCons$ ?v0 ?v1)) ?v0) :pattern ((lCons$ ?v0 ?v1)))) :named a99)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (ltl$a (lCons$a ?v0 ?v1)) ?v1) :pattern ((lCons$a ?v0 ?v1)))) :named a100)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (ltl$ (lCons$ ?v0 ?v1)) ?v1) :pattern ((lCons$ ?v0 ?v1)))) :named a101)) +(assert (! (= (ltl$a lNil$a) lNil$a) :named a102)) +(assert (! (= (ltl$ lNil$) lNil$) :named a103)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (and (=> (= ?v0 lNil$a) false) (=> (= ?v0 (lCons$a (lhd$a ?v0) (ltl$a ?v0))) false)) false)) :named a104)) +(assert (! (forall ((?v0 A_llist$)) (=> (and (=> (= ?v0 lNil$) false) (=> (= ?v0 (lCons$ (lhd$ ?v0) (ltl$ ?v0))) false)) false)) :named a105)) +(assert (! (forall ((?v0 A_llist$)) (=> (and (=> (= ?v0 lNil$) false) (forall ((?v1 A$) (?v2 A_llist$)) (=> (= ?v0 (lCons$ ?v1 ?v2)) false))) false)) :named a106)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (and (=> (= ?v0 lNil$a) false) (forall ((?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v0 (lCons$a ?v1 ?v2)) false))) false)) :named a107)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (=> (and (fun_app$bw lnull$a ?v0) (fun_app$bw lnull$a ?v1)) false) (=> (or (not (fun_app$bw lnull$a ?v0)) (not (fun_app$bw lnull$a ?v1))) false)) false)) :named a108)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (and (=> (and (fun_app$l lnull$ ?v0) (fun_app$l lnull$ ?v1)) false) (=> (or (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) false)) false)) :named a109)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (and (=> (fun_app$bw lnull$a ?v0) false) (=> (not (fun_app$bw lnull$a ?v0)) false)) false)) :named a110)) +(assert (! (forall ((?v0 A_llist$)) (=> (and (=> (fun_app$l lnull$ ?v0) false) (=> (not (fun_app$l lnull$ ?v0)) false)) false)) :named a111)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (= (fun_app$bw lnull$a ?v0) (fun_app$bw lnull$a ?v1)) (=> (and (not (fun_app$bw lnull$a ?v0)) (not (fun_app$bw lnull$a ?v1))) (and (= (lhd$a ?v0) (lhd$a ?v1)) (= (ltl$a ?v0) (ltl$a ?v1))))) (= ?v0 ?v1))) :named a112)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (and (= (fun_app$l lnull$ ?v0) (fun_app$l lnull$ ?v1)) (=> (and (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) (and (= (lhd$ ?v0) (lhd$ ?v1)) (= (ltl$ ?v0) (ltl$ ?v1))))) (= ?v0 ?v1))) :named a113)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v0 (lCons$a ?v1 ?v2)) (and (not (= ?v0 lNil$a)) (and (= (lhd$a ?v0) ?v1) (= (ltl$a ?v0) ?v2))))) :named a114)) +(assert (! (forall ((?v0 A_llist$) (?v1 A$) (?v2 A_llist$)) (=> (= ?v0 (lCons$ ?v1 ?v2)) (and (not (= ?v0 lNil$)) (and (= (lhd$ ?v0) ?v1) (= (ltl$ ?v0) ?v2))))) :named a115)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v0 (lCons$a ?v1 ?v2)) (not (fun_app$bw lnull$a ?v0)))) :named a116)) +(assert (! (forall ((?v0 A_llist$) (?v1 A$) (?v2 A_llist$)) (=> (= ?v0 (lCons$ ?v1 ?v2)) (not (fun_app$l lnull$ ?v0)))) :named a117)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (= ?v0 lNil$a) (fun_app$bw lnull$a ?v0))) :named a118)) +(assert (! (forall ((?v0 A_llist$)) (=> (= ?v0 lNil$) (fun_app$l lnull$ ?v0))) :named a119)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (fun_app$bw lnull$a ?v0) (= ?v0 lNil$a))) :named a120)) +(assert (! (forall ((?v0 A_llist$)) (=> (fun_app$l lnull$ ?v0) (= ?v0 lNil$))) :named a121)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (fun_app$bw lnull$a ?v0) (fun_app$bw lnull$a (ltl$a ?v0)))) :named a122)) +(assert (! (forall ((?v0 A_llist$)) (=> (fun_app$l lnull$ ?v0) (fun_app$l lnull$ (ltl$ ?v0)))) :named a123)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$bw (fun_app$by ?v0 ?v1) ?v2) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod_llist$)) (=> (fun_app$bw (fun_app$by ?v0 ?v3) ?v4) (and (= (fun_app$bw lnull$a ?v3) (fun_app$bw lnull$a ?v4)) (=> (and (not (fun_app$bw lnull$a ?v3)) (not (fun_app$bw lnull$a ?v4))) (and (= (lhd$a ?v3) (lhd$a ?v4)) (or (fun_app$bw (fun_app$by ?v0 (ltl$a ?v3)) (ltl$a ?v4)) (= (ltl$a ?v3) (ltl$a ?v4))))))))) (= ?v1 ?v2))) :named a124)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (=> (and (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v3) ?v4) (and (= (fun_app$l lnull$ ?v3) (fun_app$l lnull$ ?v4)) (=> (and (not (fun_app$l lnull$ ?v3)) (not (fun_app$l lnull$ ?v4))) (and (= (lhd$ ?v3) (lhd$ ?v4)) (or (fun_app$l (fun_app$m ?v0 (ltl$ ?v3)) (ltl$ ?v4)) (= (ltl$ ?v3) (ltl$ ?v4))))))))) (= ?v1 ?v2))) :named a125)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$bw (fun_app$by ?v0 ?v1) ?v2) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod_llist$)) (=> (fun_app$bw (fun_app$by ?v0 ?v3) ?v4) (and (= (fun_app$bw lnull$a ?v3) (fun_app$bw lnull$a ?v4)) (=> (and (not (fun_app$bw lnull$a ?v3)) (not (fun_app$bw lnull$a ?v4))) (and (= (lhd$a ?v3) (lhd$a ?v4)) (fun_app$bw (fun_app$by ?v0 (ltl$a ?v3)) (ltl$a ?v4)))))))) (= ?v1 ?v2))) :named a126)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (=> (and (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v3) ?v4) (and (= (fun_app$l lnull$ ?v3) (fun_app$l lnull$ ?v4)) (=> (and (not (fun_app$l lnull$ ?v3)) (not (fun_app$l lnull$ ?v4))) (and (= (lhd$ ?v3) (lhd$ ?v4)) (fun_app$l (fun_app$m ?v0 (ltl$ ?v3)) (ltl$ ?v4)))))))) (= ?v1 ?v2))) :named a127)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (not (= lNil$ (lCons$ ?v0 ?v1)))) :named a128)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (not (= lNil$a (lCons$a ?v0 ?v1)))) :named a129)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (not (fun_app$bw lnull$a (lCons$a ?v0 ?v1)))) :named a130)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (not (fun_app$l lnull$ (lCons$ ?v0 ?v1)))) :named a131)) +(assert (! (fun_app$bw lnull$a lNil$a) :named a132)) +(assert (! (fun_app$l lnull$ lNil$) :named a133)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v2 ?v3)) (fun_app$h (fun_app$r ?v1 ?v2) ?v3))) (fun_app$j (fun_app$al uncurry$d ?v1) ?v0))) :named a134)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_bool_fun_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (=> (= ?v0 (pair$ ?v2 ?v3)) (fun_app$l (fun_app$m ?v1 ?v2) ?v3))) (fun_app$h (fun_app$ad uncurry$a ?v1) ?v0))) :named a135)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$h (fun_app$r ?v0 ?v1) ?v2) (fun_app$j (fun_app$al uncurry$d ?v0) (pair$b ?v1 ?v2)))) :named a136)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (fun_app$h (fun_app$ad uncurry$a ?v0) (pair$ ?v1 ?v2)))) :named a137)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$x (fun_app$ah uncurry$b ?v0) (pair$ ?v1 ?v2)) (fun_app$n (fun_app$o ?v0 ?v1) ?v2)) :pattern ((fun_app$x (fun_app$ah uncurry$b ?v0) (pair$ ?v1 ?v2))))) :named a138)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$w (fun_app$ab uncurry$ ?v0) (pair$ ?v1 ?v2)) (fun_app$d (fun_app$e ?v0 ?v1) ?v2)) :pattern ((fun_app$w (fun_app$ab uncurry$ ?v0) (pair$ ?v1 ?v2))))) :named a139)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$j (fun_app$al uncurry$d ?v0) (pair$b ?v1 ?v2)) (fun_app$h (fun_app$r ?v0 ?v1) ?v2)) :pattern ((fun_app$j (fun_app$al uncurry$d ?v0) (pair$b ?v1 ?v2))))) :named a140)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$r (fun_app$aj uncurry$c ?v0) (pair$ ?v1 ?v2)) (fun_app$p (fun_app$q ?v0 ?v1) ?v2)) :pattern ((fun_app$r (fun_app$aj uncurry$c ?v0) (pair$ ?v1 ?v2))))) :named a141)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$h (fun_app$ad uncurry$a ?v0) (pair$ ?v1 ?v2)) (fun_app$l (fun_app$m ?v0 ?v1) ?v2)) :pattern ((fun_app$h (fun_app$ad uncurry$a ?v0) (pair$ ?v1 ?v2))))) :named a142)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$h (fun_app$r ?v0 ?v1) ?v2) (fun_app$j (fun_app$al uncurry$d ?v0) (pair$b ?v1 ?v2)))) :named a143)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (fun_app$h (fun_app$ad uncurry$a ?v0) (pair$ ?v1 ?v2)))) :named a144)) +(assert (! (forall ((?v0 Bool) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$j (fun_app$al uncurry$d (fun_app$aq (uu$ ?v0) ?v1)) ?v2) (and ?v0 (fun_app$j (fun_app$al uncurry$d ?v1) ?v2)))) :named a145)) +(assert (! (forall ((?v0 Bool) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$h (fun_app$ad uncurry$a (fun_app$ap (uua$ ?v0) ?v1)) ?v2) (and ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)))) :named a146)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (= (= (pair$b ?v0 ?v1) (pair$b ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a147)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$)) (= (= (pair$ ?v0 ?v1) (pair$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a148)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (= (= (pair$b ?v0 ?v1) (pair$b ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a149)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$)) (= (= (pair$ ?v0 ?v1) (pair$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a150)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$j (fun_app$al uncurry$d ?v0) (pair$b ?v1 ?v2)) (fun_app$h (fun_app$r ?v0 ?v1) ?v2))) :named a151)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (=> (fun_app$h (fun_app$ad uncurry$a ?v0) (pair$ ?v1 ?v2)) (fun_app$l (fun_app$m ?v0 ?v1) ?v2))) :named a152)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (fun_app$j (fun_app$al uncurry$d ?v0) ?v1) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (and (= ?v1 (pair$b ?v2 ?v3)) (fun_app$h (fun_app$r ?v0 ?v2) ?v3)) false))) false)) :named a153)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod$)) (=> (and (fun_app$h (fun_app$ad uncurry$a ?v0) ?v1) (forall ((?v2 A_llist$) (?v3 A_llist$)) (=> (and (= ?v1 (pair$ ?v2 ?v3)) (fun_app$l (fun_app$m ?v0 ?v2) ?v3)) false))) false)) :named a154)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$)) (= (fun_app$ah uncurry$b (uub$ ?v0)) ?v0)) :named a155)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_fun$)) (= (fun_app$ab uncurry$ (uuc$ ?v0)) ?v0)) :named a156)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (= (fun_app$al uncurry$d (uud$ ?v0)) ?v0)) :named a157)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (= (fun_app$aj uncurry$c (uue$ ?v0)) ?v0)) :named a158)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$)) (= (fun_app$ad uncurry$a (uuf$ ?v0)) ?v0)) :named a159)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_set_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (= (fun_app$n (fun_app$o ?v0 ?v2) ?v3) (fun_app$x ?v1 (pair$ ?v2 ?v3)))) (= (fun_app$ah uncurry$b ?v0) ?v1))) :named a160)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (= (fun_app$d (fun_app$e ?v0 ?v2) ?v3) (fun_app$w ?v1 (pair$ ?v2 ?v3)))) (= (fun_app$ab uncurry$ ?v0) ?v1))) :named a161)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (= (fun_app$h (fun_app$r ?v0 ?v2) ?v3) (fun_app$j ?v1 (pair$b ?v2 ?v3)))) (= (fun_app$al uncurry$d ?v0) ?v1))) :named a162)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (= (fun_app$p (fun_app$q ?v0 ?v2) ?v3) (fun_app$r ?v1 (pair$ ?v2 ?v3)))) (= (fun_app$aj uncurry$c ?v0) ?v1))) :named a163)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_bool_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (= (fun_app$l (fun_app$m ?v0 ?v2) ?v3) (fun_app$h ?v1 (pair$ ?v2 ?v3)))) (= (fun_app$ad uncurry$a ?v0) ?v1))) :named a164)) +(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_a_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (member$b ?v0 (fun_app$bz (fun_app$ca ?v1 ?v2) ?v3)) (member$b ?v0 (uncurry$e ?v1 (pair$ ?v2 ?v3))))) :named a165)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (member$a ?v0 (fun_app$cb (fun_app$cc ?v1 ?v2) ?v3)) (member$a ?v0 (uncurry$f ?v1 (pair$ ?v2 ?v3))))) :named a166)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v0) (fun_app$x (fun_app$cd ?v1 ?v2) ?v3)) (fun_app$i (member$ ?v0) (uncurry$g ?v1 (pair$b ?v2 ?v3))))) :named a167)) +(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (member$b ?v0 (fun_app$ce (fun_app$cf ?v1 ?v2) ?v3)) (member$b ?v0 (uncurry$h ?v1 (pair$b ?v2 ?v3))))) :named a168)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (member$a ?v0 (fun_app$cg (fun_app$ch ?v1 ?v2) ?v3)) (member$a ?v0 (uncurry$i ?v1 (pair$b ?v2 ?v3))))) :named a169)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (fun_app$i (member$ ?v0) (fun_app$n (fun_app$o ?v1 ?v2) ?v3)) (fun_app$i (member$ ?v0) (fun_app$x (fun_app$ah uncurry$b ?v1) (pair$ ?v2 ?v3))))) :named a170)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A$) (?v2 A_llist_a_llist_a_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (member$b ?v1 (fun_app$bz (fun_app$ca ?v2 ?v3) ?v4)))) (member$b ?v1 (uncurry$e ?v2 ?v0)))) :named a171)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (member$a ?v1 (fun_app$cb (fun_app$cc ?v2 ?v3) ?v4)))) (member$a ?v1 (uncurry$f ?v2 ?v0)))) :named a172)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (fun_app$i (member$ ?v1) (fun_app$x (fun_app$cd ?v2 ?v3) ?v4)))) (fun_app$i (member$ ?v1) (uncurry$g ?v2 ?v0)))) :named a173)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (member$b ?v1 (fun_app$ce (fun_app$cf ?v2 ?v3) ?v4)))) (member$b ?v1 (uncurry$h ?v2 ?v0)))) :named a174)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (member$a ?v1 (fun_app$cg (fun_app$ch ?v2 ?v3) ?v4)))) (member$a ?v1 (uncurry$i ?v2 ?v0)))) :named a175)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (fun_app$i (member$ ?v1) (fun_app$n (fun_app$o ?v2 ?v3) ?v4)))) (fun_app$i (member$ ?v1) (fun_app$x (fun_app$ah uncurry$b ?v2) ?v0)))) :named a176)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$j ?v0 ?v2) (fun_app$j ?v1 ?v2))) (= (collect$a ?v0) (collect$a ?v1)))) :named a177)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod$)) (= (fun_app$h ?v0 ?v2) (fun_app$h ?v1 ?v2))) (= (collect$ ?v0) (collect$ ?v1)))) :named a178)) +(assert (! (forall ((?v0 A_set$)) (= (collect$b (uug$ ?v0)) ?v0)) :named a179)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$)) (= (collect$a (uuh$ ?v0)) ?v0)) :named a180)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$)) (= (collect$ (uui$ ?v0)) ?v0)) :named a181)) +(assert (! (forall ((?v0 A$) (?v1 A_bool_fun$)) (= (member$b ?v0 (collect$b ?v1)) (fun_app$k ?v1 ?v0))) :named a182)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (= (member$a ?v0 (collect$a ?v1)) (fun_app$j ?v1 ?v0))) :named a183)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_bool_fun$)) (= (fun_app$i (member$ ?v0) (collect$ ?v1)) (fun_app$h ?v1 ?v0))) :named a184)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= (pair$ ?v3 ?v4) ?v0) (fun_app$h (fun_app$p (fun_app$q ?v1 ?v3) ?v4) ?v2))) (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v1) ?v0) ?v2))) :named a185)) +(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_a_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (member$b ?v0 (uncurry$e ?v1 ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (member$b ?v0 (fun_app$bz (fun_app$ca ?v1 ?v3) ?v4))) false))) false)) :named a186)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (member$a ?v0 (uncurry$f ?v1 ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (member$a ?v0 (fun_app$cb (fun_app$cc ?v1 ?v3) ?v4))) false))) false)) :named a187)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (fun_app$i (member$ ?v0) (uncurry$g ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (fun_app$i (member$ ?v0) (fun_app$x (fun_app$cd ?v1 ?v3) ?v4))) false))) false)) :named a188)) +(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (member$b ?v0 (uncurry$h ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (member$b ?v0 (fun_app$ce (fun_app$cf ?v1 ?v3) ?v4))) false))) false)) :named a189)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (member$a ?v0 (uncurry$i ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (member$a ?v0 (fun_app$cg (fun_app$ch ?v1 ?v3) ?v4))) false))) false)) :named a190)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v0) (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (fun_app$i (member$ ?v0) (fun_app$n (fun_app$o ?v1 ?v3) ?v4))) false))) false)) :named a191)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v0) ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v1 (pair$ ?v3 ?v4)) (fun_app$h (fun_app$p (fun_app$q ?v0 ?v3) ?v4) ?v2)) false))) false)) :named a192)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= (pair$ ?v3 ?v4) ?v0) (fun_app$h (fun_app$p (fun_app$q ?v1 ?v3) ?v4) ?v2))) (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v1) ?v0) ?v2))) :named a193)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v0) ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v1 (pair$ ?v3 ?v4)) (fun_app$h (fun_app$p (fun_app$q ?v0 ?v3) ?v4) ?v2)) false))) false)) :named a194)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist_a_llist_prod$)) (=> (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v0) (pair$ ?v1 ?v2)) ?v3) (fun_app$h (fun_app$p (fun_app$q ?v0 ?v1) ?v2) ?v3))) :named a195)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (exists ((?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (= ?v0 (pair$b ?v1 ?v2)))) :named a196)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$)) (exists ((?v1 A_llist$) (?v2 A_llist$)) (= ?v0 (pair$ ?v1 ?v2)))) :named a197)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (and (= (pair$b ?v0 ?v1) (pair$b ?v2 ?v3)) (=> (and (= ?v0 ?v2) (= ?v1 ?v3)) false)) false)) :named a198)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$)) (=> (and (= (pair$ ?v0 ?v1) (pair$ ?v2 ?v3)) (=> (and (= ?v0 ?v2) (= ?v1 ?v3)) false)) false)) :named a199)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (fun_app$j ?v0 (pair$b ?v2 ?v3))) (fun_app$j ?v0 ?v1))) :named a200)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (fun_app$h ?v0 (pair$ ?v2 ?v3))) (fun_app$h ?v0 ?v1))) :named a201)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (forall ((?v1 A_llist_a_llist_prod$) (?v2 A_llist$) (?v3 A_llist$)) (=> (= ?v0 (pair$b ?v1 (pair$ ?v2 ?v3))) false)) false)) :named a202)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist$) (?v4 A_llist$)) (fun_app$j ?v0 (pair$b ?v2 (pair$ ?v3 ?v4)))) (fun_app$j ?v0 ?v1))) :named a203)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (forall ((?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v1 ?v2)) false)) false)) :named a204)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$)) (=> (forall ((?v1 A_llist$) (?v2 A_llist$)) (=> (= ?v0 (pair$ ?v1 ?v2)) false)) false)) :named a205)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$)) (=> (= ?v0 ?v1) (= (fun_app$x (fun_app$ah uncurry$b ?v2) ?v0) (fun_app$x (fun_app$ah uncurry$b ?v2) ?v1)))) :named a206)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$)) (=> (= ?v0 ?v1) (= (fun_app$w (fun_app$ab uncurry$ ?v2) ?v0) (fun_app$w (fun_app$ab uncurry$ ?v2) ?v1)))) :named a207)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (= ?v0 ?v1) (= (fun_app$j (fun_app$al uncurry$d ?v2) ?v0) (fun_app$j (fun_app$al uncurry$d ?v2) ?v1)))) :named a208)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$)) (=> (= ?v0 ?v1) (= (fun_app$r (fun_app$aj uncurry$c ?v2) ?v0) (fun_app$r (fun_app$aj uncurry$c ?v2) ?v1)))) :named a209)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_bool_fun_fun$)) (=> (= ?v0 ?v1) (= (fun_app$h (fun_app$ad uncurry$a ?v2) ?v0) (fun_app$h (fun_app$ad uncurry$a ?v2) ?v1)))) :named a210)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$az ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$ap (uuj$ ?v0) ?v1)) ?v2))) :named a211)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$ay ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$w (fun_app$ab uncurry$ (uuk$ ?v0 ?v1)) ?v2))) :named a212)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$h ?v0 (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$ac (uul$ ?v0) ?v1)) ?v2))) :named a213)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_set_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$bc ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$x (fun_app$ah uncurry$b (fun_app$bb (uum$ ?v0) ?v1)) ?v2))) :named a214)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$i ?v0 (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$bi (uun$ ?v0) ?v1)) ?v2))) :named a215)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$be ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$r (fun_app$aj uncurry$c (fun_app$bd (uuo$ ?v0) ?v1)) ?v2))) :named a216)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$az ?v0 (fun_app$j (fun_app$al uncurry$d ?v1) ?v2)) (fun_app$j (fun_app$al uncurry$d (fun_app$aq (uup$ ?v0) ?v1)) ?v2))) :named a217)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$bk ?v0 (fun_app$r (fun_app$aj uncurry$c ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$bj (uuq$ ?v0) ?v1)) ?v2))) :named a218)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$w ?v0 (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$w (fun_app$ab uncurry$ (uur$ ?v0 ?v1)) ?v2))) :named a219)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$bh ?v0 (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (fun_app$w (fun_app$ab uncurry$ (uus$ ?v0 ?v1)) ?v2))) :named a220)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$az ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$ap (uuj$ ?v0) ?v1)) ?v2))) :named a221)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$ay ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$w (fun_app$ab uncurry$ (uuk$ ?v0 ?v1)) ?v2))) :named a222)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$h ?v0 (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$ac (uul$ ?v0) ?v1)) ?v2))) :named a223)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_set_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$bc ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$x (fun_app$ah uncurry$b (fun_app$bb (uum$ ?v0) ?v1)) ?v2))) :named a224)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$i ?v0 (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$bi (uun$ ?v0) ?v1)) ?v2))) :named a225)) +(assert (! (forall ((?v0 Bool_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$be ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (fun_app$r (fun_app$aj uncurry$c (fun_app$bd (uuo$ ?v0) ?v1)) ?v2))) :named a226)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$az ?v0 (fun_app$j (fun_app$al uncurry$d ?v1) ?v2)) (fun_app$j (fun_app$al uncurry$d (fun_app$aq (uup$ ?v0) ?v1)) ?v2))) :named a227)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$bk ?v0 (fun_app$r (fun_app$aj uncurry$c ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$bj (uuq$ ?v0) ?v1)) ?v2))) :named a228)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$w ?v0 (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$w (fun_app$ab uncurry$ (uur$ ?v0 ?v1)) ?v2))) :named a229)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set_a_llist_a_llist_prod_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$bh ?v0 (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (fun_app$w (fun_app$ab uncurry$ (uus$ ?v0 ?v1)) ?v2))) :named a230)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$h (fun_app$ad uncurry$a ?v0) (uncurry$j ?v1 ?v2)) (fun_app$j (fun_app$al uncurry$d (fun_app$ae (uut$ ?v0) ?v1)) ?v2))) :named a231)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$x (fun_app$ah uncurry$b ?v0) (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$x (fun_app$ah uncurry$b (fun_app$ag (uuu$ ?v0) ?v1)) ?v2))) :named a232)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$w (fun_app$ab uncurry$ ?v0) (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$w (fun_app$ab uncurry$ (uuv$ ?v0 ?v1)) ?v2))) :named a233)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$j (fun_app$al uncurry$d ?v0) (uncurry$k ?v1 ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$ak (uuw$ ?v0) ?v1)) ?v2))) :named a234)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$j (fun_app$al uncurry$d ?v0) (uncurry$l ?v1 ?v2)) (fun_app$j (fun_app$al uncurry$d (fun_app$ao (uux$ ?v0) ?v1)) ?v2))) :named a235)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$r (fun_app$aj uncurry$c ?v0) (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$r (fun_app$aj uncurry$c (fun_app$ai (uuy$ ?v0) ?v1)) ?v2))) :named a236)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$h (fun_app$ad uncurry$a ?v0) (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (fun_app$h (fun_app$ad uncurry$a (fun_app$ac (uuz$ ?v0) ?v1)) ?v2))) :named a237)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (= ?v0 ?v0) (fun_app$j (fun_app$al uncurry$d uva$) ?v0))) :named a238)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$)) (= (= ?v0 ?v0) (fun_app$h (fun_app$ad uncurry$a uvb$) ?v0))) :named a239)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$x (fun_app$ah uncurry$b ?v0) (pair$ ?v1 ?v2)) (fun_app$n (fun_app$o ?v0 ?v1) ?v2)) :pattern ((fun_app$x (fun_app$ah uncurry$b ?v0) (pair$ ?v1 ?v2))))) :named a240)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$w (fun_app$ab uncurry$ ?v0) (pair$ ?v1 ?v2)) (fun_app$d (fun_app$e ?v0 ?v1) ?v2)) :pattern ((fun_app$w (fun_app$ab uncurry$ ?v0) (pair$ ?v1 ?v2))))) :named a241)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$j (fun_app$al uncurry$d ?v0) (pair$b ?v1 ?v2)) (fun_app$h (fun_app$r ?v0 ?v1) ?v2)) :pattern ((fun_app$j (fun_app$al uncurry$d ?v0) (pair$b ?v1 ?v2))))) :named a242)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$r (fun_app$aj uncurry$c ?v0) (pair$ ?v1 ?v2)) (fun_app$p (fun_app$q ?v0 ?v1) ?v2)) :pattern ((fun_app$r (fun_app$aj uncurry$c ?v0) (pair$ ?v1 ?v2))))) :named a243)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$h (fun_app$ad uncurry$a ?v0) (pair$ ?v1 ?v2)) (fun_app$l (fun_app$m ?v0 ?v1) ?v2)) :pattern ((fun_app$h (fun_app$ad uncurry$a ?v0) (pair$ ?v1 ?v2))))) :named a244)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (fun_app$j (fun_app$al uncurry$d ?v0) ?v1) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (and (= ?v1 (pair$b ?v2 ?v3)) (fun_app$h (fun_app$r ?v0 ?v2) ?v3)) false))) false)) :named a245)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod$)) (=> (and (fun_app$h (fun_app$ad uncurry$a ?v0) ?v1) (forall ((?v2 A_llist$) (?v3 A_llist$)) (=> (and (= ?v1 (pair$ ?v2 ?v3)) (fun_app$l (fun_app$m ?v0 ?v2) ?v3)) false))) false)) :named a246)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v2 ?v3)) (fun_app$h (fun_app$r ?v1 ?v2) ?v3))) (fun_app$j (fun_app$al uncurry$d ?v1) ?v0))) :named a247)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_bool_fun_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (=> (= ?v0 (pair$ ?v2 ?v3)) (fun_app$l (fun_app$m ?v1 ?v2) ?v3))) (fun_app$h (fun_app$ad uncurry$a ?v1) ?v0))) :named a248)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$i ?v0 (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (fun_app$i ?v0 (fun_app$n (fun_app$o ?v1 ?v3) ?v4))) false))) false)) :named a249)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$h ?v0 (fun_app$w (fun_app$ab uncurry$ ?v1) ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (fun_app$h ?v0 (fun_app$d (fun_app$e ?v1 ?v3) ?v4))) false))) false)) :named a250)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (fun_app$az ?v0 (fun_app$j (fun_app$al uncurry$d ?v1) ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (fun_app$az ?v0 (fun_app$h (fun_app$r ?v1 ?v3) ?v4))) false))) false)) :named a251)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun_bool_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$bk ?v0 (fun_app$r (fun_app$aj uncurry$c ?v1) ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (fun_app$bk ?v0 (fun_app$p (fun_app$q ?v1 ?v3) ?v4))) false))) false)) :named a252)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$az ?v0 (fun_app$h (fun_app$ad uncurry$a ?v1) ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (fun_app$az ?v0 (fun_app$l (fun_app$m ?v1 ?v3) ?v4))) false))) false)) :named a253)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 Bool) (?v2 A_a_llist_bool_fun_fun$) (?v3 A_llist$)) (= (fun_app$az ?v0 (fun_app$l (fun_app$ci (case_llist$ ?v1) ?v2) ?v3)) (and (=> (= ?v3 lNil$) (fun_app$az ?v0 ?v1)) (=> (= ?v3 (lCons$ (lhd$ ?v3) (ltl$ ?v3))) (fun_app$az ?v0 (fun_app$l (fun_app$as ?v2 (lhd$ ?v3)) (ltl$ ?v3))))))) :named a254)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_a_llist_a_llist_fun_fun$) (?v3 A_llist$)) (= (fun_app$l ?v0 (fun_app$a (fun_app$cj (case_llist$a ?v1) ?v2) ?v3)) (and (=> (= ?v3 lNil$) (fun_app$l ?v0 ?v1)) (=> (= ?v3 (lCons$ (lhd$ ?v3) (ltl$ ?v3))) (fun_app$l ?v0 (fun_app$a (fun_app$v ?v2 (lhd$ ?v3)) (ltl$ ?v3))))))) :named a255)) +(assert (! (forall ((?v0 A_bool_fun$) (?v1 A$) (?v2 A_a_llist_a_fun_fun$) (?v3 A_llist$)) (= (fun_app$k ?v0 (fun_app$c (fun_app$ck (case_llist$b ?v1) ?v2) ?v3)) (and (=> (= ?v3 lNil$) (fun_app$k ?v0 ?v1)) (=> (= ?v3 (lCons$ (lhd$ ?v3) (ltl$ ?v3))) (fun_app$k ?v0 (fun_app$c (fun_app$au ?v2 (lhd$ ?v3)) (ltl$ ?v3))))))) :named a256)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 Bool) (?v2 A_a_llist_bool_fun_fun$) (?v3 A_llist$)) (= (fun_app$az ?v0 (fun_app$l (fun_app$ci (case_llist$ ?v1) ?v2) ?v3)) (not (or (and (= ?v3 lNil$) (not (fun_app$az ?v0 ?v1))) (and (= ?v3 (lCons$ (lhd$ ?v3) (ltl$ ?v3))) (not (fun_app$az ?v0 (fun_app$l (fun_app$as ?v2 (lhd$ ?v3)) (ltl$ ?v3))))))))) :named a257)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_a_llist_a_llist_fun_fun$) (?v3 A_llist$)) (= (fun_app$l ?v0 (fun_app$a (fun_app$cj (case_llist$a ?v1) ?v2) ?v3)) (not (or (and (= ?v3 lNil$) (not (fun_app$l ?v0 ?v1))) (and (= ?v3 (lCons$ (lhd$ ?v3) (ltl$ ?v3))) (not (fun_app$l ?v0 (fun_app$a (fun_app$v ?v2 (lhd$ ?v3)) (ltl$ ?v3))))))))) :named a258)) +(assert (! (forall ((?v0 A_bool_fun$) (?v1 A$) (?v2 A_a_llist_a_fun_fun$) (?v3 A_llist$)) (= (fun_app$k ?v0 (fun_app$c (fun_app$ck (case_llist$b ?v1) ?v2) ?v3)) (not (or (and (= ?v3 lNil$) (not (fun_app$k ?v0 ?v1))) (and (= ?v3 (lCons$ (lhd$ ?v3) (ltl$ ?v3))) (not (fun_app$k ?v0 (fun_app$c (fun_app$au ?v2 (lhd$ ?v3)) (ltl$ ?v3))))))))) :named a259)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v3 A_llist_a_llist_prod$)) (=> (and (forall ((?v4 A_llist$) (?v5 A_llist$)) (=> (= (pair$ ?v4 ?v5) ?v0) (= (fun_app$n (fun_app$o ?v1 ?v4) ?v5) (fun_app$n (fun_app$o ?v2 ?v4) ?v5)))) (= ?v3 ?v0)) (= (fun_app$x (fun_app$ah uncurry$b ?v1) ?v3) (fun_app$x (fun_app$ah uncurry$b ?v2) ?v0)))) :named a260)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v3 A_llist_a_llist_prod$)) (=> (and (forall ((?v4 A_llist$) (?v5 A_llist$)) (=> (= (pair$ ?v4 ?v5) ?v0) (= (fun_app$d (fun_app$e ?v1 ?v4) ?v5) (fun_app$d (fun_app$e ?v2 ?v4) ?v5)))) (= ?v3 ?v0)) (= (fun_app$w (fun_app$ab uncurry$ ?v1) ?v3) (fun_app$w (fun_app$ab uncurry$ ?v2) ?v0)))) :named a261)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v3 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (forall ((?v4 A_llist_a_llist_prod$) (?v5 A_llist_a_llist_prod$)) (=> (= (pair$b ?v4 ?v5) ?v0) (= (fun_app$h (fun_app$r ?v1 ?v4) ?v5) (fun_app$h (fun_app$r ?v2 ?v4) ?v5)))) (= ?v3 ?v0)) (= (fun_app$j (fun_app$al uncurry$d ?v1) ?v3) (fun_app$j (fun_app$al uncurry$d ?v2) ?v0)))) :named a262)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v3 A_llist_a_llist_prod$)) (=> (and (forall ((?v4 A_llist$) (?v5 A_llist$)) (=> (= (pair$ ?v4 ?v5) ?v0) (= (fun_app$p (fun_app$q ?v1 ?v4) ?v5) (fun_app$p (fun_app$q ?v2 ?v4) ?v5)))) (= ?v3 ?v0)) (= (fun_app$r (fun_app$aj uncurry$c ?v1) ?v3) (fun_app$r (fun_app$aj uncurry$c ?v2) ?v0)))) :named a263)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_bool_fun_fun$) (?v2 A_llist_a_llist_bool_fun_fun$) (?v3 A_llist_a_llist_prod$)) (=> (and (forall ((?v4 A_llist$) (?v5 A_llist$)) (=> (= (pair$ ?v4 ?v5) ?v0) (= (fun_app$l (fun_app$m ?v1 ?v4) ?v5) (fun_app$l (fun_app$m ?v2 ?v4) ?v5)))) (= ?v3 ?v0)) (= (fun_app$h (fun_app$ad uncurry$a ?v1) ?v3) (fun_app$h (fun_app$ad uncurry$a ?v2) ?v0)))) :named a264)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (= (unfold_llist$ lnull$a uvc$ uvd$ ?v0) ?v0)) :named a265)) +(assert (! (forall ((?v0 A_llist$)) (= (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a lnull$) uve$) uvf$) ?v0) ?v0)) :named a266)) +(assert (! (forall ((?v0 Bool) (?v1 A_a_llist_bool_fun_fun$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$ci (case_llist$ ?v0) ?v1) ?v2) (ite (fun_app$l lnull$ ?v2) ?v0 (fun_app$l (fun_app$as ?v1 (lhd$ ?v2)) (ltl$ ?v2)))) :pattern ((fun_app$l (fun_app$ci (case_llist$ ?v0) ?v1) ?v2)))) :named a267)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_a_llist_a_llist_fun_fun$) (?v2 A_llist$)) (! (= (fun_app$a (fun_app$cj (case_llist$a ?v0) ?v1) ?v2) (ite (fun_app$l lnull$ ?v2) ?v0 (fun_app$a (fun_app$v ?v1 (lhd$ ?v2)) (ltl$ ?v2)))) :pattern ((fun_app$a (fun_app$cj (case_llist$a ?v0) ?v1) ?v2)))) :named a268)) +(assert (! (forall ((?v0 A$) (?v1 A_a_llist_a_fun_fun$) (?v2 A_llist$)) (! (= (fun_app$c (fun_app$ck (case_llist$b ?v0) ?v1) ?v2) (ite (fun_app$l lnull$ ?v2) ?v0 (fun_app$c (fun_app$au ?v1 (lhd$ ?v2)) (ltl$ ?v2)))) :pattern ((fun_app$c (fun_app$ck (case_llist$b ?v0) ?v1) ?v2)))) :named a269)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (= (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v0) ?v1) ?v2) (fun_app$h (fun_app$ad uncurry$a (fun_app$y (uvg$ ?v0) ?v2)) ?v1))) :named a270)) +(assert (! (= internal_split$ uncurry$b) :named a271)) +(assert (! (= internal_split$a uncurry$) :named a272)) +(assert (! (= internal_split$b uncurry$d) :named a273)) +(assert (! (= internal_split$c uncurry$c) :named a274)) +(assert (! (= internal_split$d uncurry$a) :named a275)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_fun$) (?v2 A_llist_a_llist_fun$) (?v3 A_llist$)) (= (not (fun_app$l lnull$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) ?v3))) (not (fun_app$l ?v0 ?v3)))) :named a276)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_fun$) (?v2 A_llist_a_llist_fun$) (?v3 A_llist$)) (= (fun_app$l lnull$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) ?v3)) (fun_app$l ?v0 ?v3))) :named a277)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_fun$) (?v2 A_llist_a_llist_fun$) (?v3 A_llist$) (?v4 A$) (?v5 A_llist$)) (= (= (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) ?v3) (lCons$ ?v4 ?v5)) (and (not (fun_app$l ?v0 ?v3)) (and (= ?v4 (fun_app$c ?v1 ?v3)) (= ?v5 (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) (fun_app$a ?v2 ?v3))))))) :named a278)) +(assert (! (forall ((?v0 Bool_bool_fun$) (?v1 Bool) (?v2 A_a_llist_bool_fun_fun$) (?v3 A_llist$)) (= (fun_app$az ?v0 (fun_app$l (fun_app$ci (case_llist$ ?v1) ?v2) ?v3)) (fun_app$l (fun_app$ci (case_llist$ (fun_app$az ?v0 ?v1)) (fun_app$ba (uvh$ ?v0) ?v2)) ?v3))) :named a279)) +(assert (! (forall ((?v0 Bool_a_llist_fun$) (?v1 Bool) (?v2 A_a_llist_bool_fun_fun$) (?v3 A_llist$)) (= (fun_app$ax ?v0 (fun_app$l (fun_app$ci (case_llist$ ?v1) ?v2) ?v3)) (fun_app$a (fun_app$cj (case_llist$a (fun_app$ax ?v0 ?v1)) (fun_app$aw (uvi$ ?v0) ?v2)) ?v3))) :named a280)) +(assert (! (forall ((?v0 Bool_a_fun$) (?v1 Bool) (?v2 A_a_llist_bool_fun_fun$) (?v3 A_llist$)) (= (fun_app$bg ?v0 (fun_app$l (fun_app$ci (case_llist$ ?v1) ?v2) ?v3)) (fun_app$c (fun_app$ck (case_llist$b (fun_app$bg ?v0 ?v1)) (fun_app$bf (uvj$ ?v0) ?v2)) ?v3))) :named a281)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_a_llist_a_llist_fun_fun$) (?v3 A_llist$)) (= (fun_app$l ?v0 (fun_app$a (fun_app$cj (case_llist$a ?v1) ?v2) ?v3)) (fun_app$l (fun_app$ci (case_llist$ (fun_app$l ?v0 ?v1)) (fun_app$at (uvk$ ?v0) ?v2)) ?v3))) :named a282)) +(assert (! (forall ((?v0 A_llist_a_llist_fun$) (?v1 A_llist$) (?v2 A_a_llist_a_llist_fun_fun$) (?v3 A_llist$)) (= (fun_app$a ?v0 (fun_app$a (fun_app$cj (case_llist$a ?v1) ?v2) ?v3)) (fun_app$a (fun_app$cj (case_llist$a (fun_app$a ?v0 ?v1)) (fun_app$ar (uvl$ ?v0) ?v2)) ?v3))) :named a283)) +(assert (! (forall ((?v0 A_llist_a_fun$) (?v1 A_llist$) (?v2 A_a_llist_a_llist_fun_fun$) (?v3 A_llist$)) (= (fun_app$c ?v0 (fun_app$a (fun_app$cj (case_llist$a ?v1) ?v2) ?v3)) (fun_app$c (fun_app$ck (case_llist$b (fun_app$c ?v0 ?v1)) (fun_app$av (uvm$ ?v0) ?v2)) ?v3))) :named a284)) +(assert (! (forall ((?v0 A_bool_fun$) (?v1 A$) (?v2 A_a_llist_a_fun_fun$) (?v3 A_llist$)) (= (fun_app$k ?v0 (fun_app$c (fun_app$ck (case_llist$b ?v1) ?v2) ?v3)) (fun_app$l (fun_app$ci (case_llist$ (fun_app$k ?v0 ?v1)) (fun_app$bn (uvn$ ?v0) ?v2)) ?v3))) :named a285)) +(assert (! (forall ((?v0 A_a_llist_fun$) (?v1 A$) (?v2 A_a_llist_a_fun_fun$) (?v3 A_llist$)) (= (fun_app$bm ?v0 (fun_app$c (fun_app$ck (case_llist$b ?v1) ?v2) ?v3)) (fun_app$a (fun_app$cj (case_llist$a (fun_app$bm ?v0 ?v1)) (fun_app$bl (uvo$ ?v0) ?v2)) ?v3))) :named a286)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A$) (?v2 A_a_llist_a_fun_fun$) (?v3 A_llist$)) (= (fun_app$bp ?v0 (fun_app$c (fun_app$ck (case_llist$b ?v1) ?v2) ?v3)) (fun_app$c (fun_app$ck (case_llist$b (fun_app$bp ?v0 ?v1)) (fun_app$bo (uvp$ ?v0) ?v2)) ?v3))) :named a287)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist_a_fun$) (?v3 A_llist_a_llist_fun$)) (=> (not (fun_app$l ?v0 ?v1)) (not (fun_app$l lnull$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) ?v1))))) :named a288)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist_a_fun$) (?v3 A_llist_a_llist_fun$)) (=> (fun_app$l ?v0 ?v1) (fun_app$l lnull$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) ?v1)))) :named a289)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist_a_fun$) (?v3 A_llist_a_llist_fun$)) (=> (not (fun_app$l ?v0 ?v1)) (= (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) ?v1) (lCons$ (fun_app$c ?v2 ?v1) (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) (fun_app$a ?v3 ?v1)))))) :named a290)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist_a_fun$) (?v3 A_llist_a_llist_fun$)) (! (=> (fun_app$l ?v0 ?v1) (= (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) ?v1) lNil$)) :pattern ((fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) ?v1)))) :named a291)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist_a_fun$) (?v3 A_llist_a_llist_fun$)) (=> (not (fun_app$l ?v0 ?v1)) (= (ltl$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) ?v1)) (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) (fun_app$a ?v3 ?v1))))) :named a292)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist_a_fun$) (?v3 A_llist_a_llist_fun$)) (=> (not (fun_app$l ?v0 ?v1)) (= (lhd$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v2) ?v3) ?v1)) (fun_app$c ?v2 ?v1)))) :named a293)) +(assert (! (forall ((?v0 Bool) (?v1 A_a_llist_bool_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$ci (case_llist$ ?v0) ?v1) (lCons$ ?v2 ?v3)) (fun_app$l (fun_app$as ?v1 ?v2) ?v3)) :pattern ((fun_app$l (fun_app$ci (case_llist$ ?v0) ?v1) (lCons$ ?v2 ?v3))))) :named a294)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_a_llist_a_llist_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$a (fun_app$cj (case_llist$a ?v0) ?v1) (lCons$ ?v2 ?v3)) (fun_app$a (fun_app$v ?v1 ?v2) ?v3)) :pattern ((fun_app$a (fun_app$cj (case_llist$a ?v0) ?v1) (lCons$ ?v2 ?v3))))) :named a295)) +(assert (! (forall ((?v0 A$) (?v1 A_a_llist_a_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$c (fun_app$ck (case_llist$b ?v0) ?v1) (lCons$ ?v2 ?v3)) (fun_app$c (fun_app$au ?v1 ?v2) ?v3)) :pattern ((fun_app$c (fun_app$ck (case_llist$b ?v0) ?v1) (lCons$ ?v2 ?v3))))) :named a296)) +(assert (! (forall ((?v0 Bool) (?v1 A_a_llist_bool_fun_fun$)) (! (= (fun_app$l (fun_app$ci (case_llist$ ?v0) ?v1) lNil$) ?v0) :pattern ((fun_app$ci (case_llist$ ?v0) ?v1)))) :named a297)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_a_llist_a_llist_fun_fun$)) (! (= (fun_app$a (fun_app$cj (case_llist$a ?v0) ?v1) lNil$) ?v0) :pattern ((fun_app$cj (case_llist$a ?v0) ?v1)))) :named a298)) +(assert (! (forall ((?v0 A$) (?v1 A_a_llist_a_fun_fun$)) (! (= (fun_app$c (fun_app$ck (case_llist$b ?v0) ?v1) lNil$) ?v0) :pattern ((fun_app$ck (case_llist$b ?v0) ?v1)))) :named a299)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (= (not (fun_app$bw lnull$a ?v0)) (fun_app$bw (fun_app$cn (case_llist$c false) uvq$) ?v0))) :named a300)) +(assert (! (forall ((?v0 A_llist$)) (= (not (fun_app$l lnull$ ?v0)) (fun_app$l (fun_app$ci (case_llist$ false) uvr$) ?v0))) :named a301)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (! (= (fun_app$bw lnull$a ?v0) (fun_app$bw (fun_app$cn (case_llist$c true) uvs$) ?v0)) :pattern ((fun_app$bw lnull$a ?v0)))) :named a302)) +(assert (! (forall ((?v0 A_llist$)) (! (= (fun_app$l lnull$ ?v0) (fun_app$l (fun_app$ci (case_llist$ true) uvt$) ?v0)) :pattern ((fun_app$l lnull$ ?v0)))) :named a303)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_fun$) (?v2 A_llist_a_llist_fun$) (?v3 A_llist$)) (= (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) ?v3) (ite (fun_app$l ?v0 ?v3) lNil$ (lCons$ (fun_app$c ?v1 ?v3) (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) (fun_app$a ?v2 ?v3)))))) :named a304)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_fun$) (?v2 A_llist_a_llist_fun$) (?v3 A_llist$)) (= (ltl$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) ?v3)) (ite (fun_app$l ?v0 ?v3) lNil$ (fun_app$a (fun_app$cl (fun_app$cm (unfold_llist$a ?v0) ?v1) ?v2) (fun_app$a ?v2 ?v3))))) :named a305)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (= (ltl$a ?v0) (case_llist$d lNil$a uvu$ ?v0))) :named a306)) +(assert (! (forall ((?v0 A_llist$)) (= (ltl$ ?v0) (fun_app$a (fun_app$cj (case_llist$a lNil$) uvv$) ?v0))) :named a307)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$h (fun_app$ad internal_split$d ?v0) (pair$ ?v1 ?v2)) (fun_app$l (fun_app$m ?v0 ?v1) ?v2)) :pattern ((fun_app$h (fun_app$ad internal_split$d ?v0) (pair$ ?v1 ?v2))))) :named a308)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (! (= (uncurry$l uvw$ ?v0) ?v0) :pattern ((uncurry$l uvw$ ?v0)))) :named a309)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$)) (! (= (fun_app$w (fun_app$ab uncurry$ uvx$) ?v0) ?v0) :pattern ((fun_app$w (fun_app$ab uncurry$ uvx$) ?v0)))) :named a310)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$)) (= (= (uvy$ ?v0) (uvy$ ?v1)) (= ?v0 ?v1))) :named a311)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (= (uvz$ ?v0) (uvz$ ?v1)) (= ?v0 ?v1))) :named a312)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (=> (or (not (fun_app$bw lnull$a ?v0)) (not (fun_app$bw lnull$a ?v1))) (= (lhd$a (fun_app$ (lappend$ ?v0) ?v1)) (case_llist$e (lhd$a ?v1) uwa$ ?v0)))) :named a313)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (or (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) (= (lhd$ (fun_app$a (lappend$a ?v0) ?v1)) (fun_app$c (fun_app$ck (case_llist$b (lhd$ ?v1)) uwb$) ?v0)))) :named a314)) +(assert (! (forall ((?v0 A_bool_fun$) (?v1 A$) (?v2 A_llist$)) (! (= (fun_app$l (pred_llist$ ?v0) (lCons$ ?v1 ?v2)) (and (fun_app$k ?v0 ?v1) (fun_app$l (pred_llist$ ?v0) ?v2))) :pattern ((fun_app$l (pred_llist$ ?v0) (lCons$ ?v1 ?v2))))) :named a315)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (! (= (fun_app$bw (pred_llist$a ?v0) (lCons$a ?v1 ?v2)) (and (fun_app$h ?v0 ?v1) (fun_app$bw (pred_llist$a ?v0) ?v2))) :pattern ((fun_app$bw (pred_llist$a ?v0) (lCons$a ?v1 ?v2))))) :named a316)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$)) (! (= (fun_app$bw (lmember$ ?v0) lNil$a) false) :pattern ((lmember$ ?v0)))) :named a317)) +(assert (! (forall ((?v0 A$)) (! (= (fun_app$l (lmember$a ?v0) lNil$) false) :pattern ((lmember$a ?v0)))) :named a318)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist_a_llist_prod$)) (= (fun_app$x (fun_app$ah uncurry$b (uwc$ ?v0)) (swap$ ?v1)) (fun_app$x (fun_app$ah uncurry$b ?v0) ?v1))) :named a319)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist_a_llist_prod$)) (= (fun_app$w (fun_app$ab uncurry$ (uwd$ ?v0)) (swap$ ?v1)) (fun_app$w (fun_app$ab uncurry$ ?v0) ?v1))) :named a320)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$j (fun_app$al uncurry$d (uwe$ ?v0)) (swap$a ?v1)) (fun_app$j (fun_app$al uncurry$d ?v0) ?v1))) :named a321)) +(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$)) (= (fun_app$r (fun_app$aj uncurry$c (uwf$ ?v0)) (swap$ ?v1)) (fun_app$r (fun_app$aj uncurry$c ?v0) ?v1))) :named a322)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod$)) (= (fun_app$h (fun_app$ad uncurry$a (uwg$ ?v0)) (swap$ ?v1)) (fun_app$h (fun_app$ad uncurry$a ?v0) ?v1))) :named a323)) +(assert (! (forall ((?v0 A$) (?v1 A$) (?v2 A_llist$)) (! (= (fun_app$l (lmember$a ?v0) (lCons$ ?v1 ?v2)) (or (= ?v0 ?v1) (fun_app$l (lmember$a ?v0) ?v2))) :pattern ((fun_app$l (lmember$a ?v0) (lCons$ ?v1 ?v2))))) :named a324)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (! (= (fun_app$bw (lmember$ ?v0) (lCons$a ?v1 ?v2)) (or (= ?v0 ?v1) (fun_app$bw (lmember$ ?v0) ?v2))) :pattern ((fun_app$bw (lmember$ ?v0) (lCons$a ?v1 ?v2))))) :named a325)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$)) (= (swap$ (swap$ ?v0)) ?v0)) :named a326)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (fun_app$bw lnull$a (fun_app$ (lappend$ ?v0) ?v1)) (and (fun_app$bw lnull$a ?v0) (fun_app$bw lnull$a ?v1)))) :named a327)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (fun_app$l lnull$ (fun_app$a (lappend$a ?v0) ?v1)) (and (fun_app$l lnull$ ?v0) (fun_app$l lnull$ ?v1)))) :named a328)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (not (fun_app$bw lnull$a (fun_app$ (lappend$ ?v0) ?v1))) (or (not (fun_app$bw lnull$a ?v0)) (not (fun_app$bw lnull$a ?v1))))) :named a329)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (not (fun_app$l lnull$ (fun_app$a (lappend$a ?v0) ?v1))) (or (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))))) :named a330)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$a (lappend$a (lCons$ ?v0 ?v1)) ?v2) (lCons$ ?v0 (fun_app$a (lappend$a ?v1) ?v2))) :pattern ((fun_app$a (lappend$a (lCons$ ?v0 ?v1)) ?v2)))) :named a331)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ (lappend$ (lCons$a ?v0 ?v1)) ?v2) (lCons$a ?v0 (fun_app$ (lappend$ ?v1) ?v2))) :pattern ((fun_app$ (lappend$ (lCons$a ?v0 ?v1)) ?v2)))) :named a332)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ (lappend$ lNil$a) ?v0) ?v0) :pattern ((fun_app$ (lappend$ lNil$a) ?v0)))) :named a333)) +(assert (! (forall ((?v0 A_llist$)) (! (= (fun_app$a (lappend$a lNil$) ?v0) ?v0) :pattern ((fun_app$a (lappend$a lNil$) ?v0)))) :named a334)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ (lappend$ ?v0) lNil$a) ?v0) :pattern ((lappend$ ?v0)))) :named a335)) +(assert (! (forall ((?v0 A_llist$)) (! (= (fun_app$a (lappend$a ?v0) lNil$) ?v0) :pattern ((lappend$a ?v0)))) :named a336)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$)) (= (swap$a (pair$b ?v0 ?v1)) (pair$b ?v1 ?v0))) :named a337)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (swap$ (pair$ ?v0 ?v1)) (pair$ ?v1 ?v0))) :named a338)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (ltl$a (fun_app$ (lappend$ ?v0) ?v1)) (ite (fun_app$bw lnull$a ?v0) (ltl$a ?v1) (fun_app$ (lappend$ (ltl$a ?v0)) ?v1)))) :named a339)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (ltl$ (fun_app$a (lappend$a ?v0) ?v1)) (ite (fun_app$l lnull$ ?v0) (ltl$ ?v1) (fun_app$a (lappend$a (ltl$ ?v0)) ?v1)))) :named a340)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (lhd$a (fun_app$ (lappend$ ?v0) ?v1)) (ite (fun_app$bw lnull$a ?v0) (lhd$a ?v1) (lhd$a ?v0)))) :named a341)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (lhd$ (fun_app$a (lappend$a ?v0) ?v1)) (ite (fun_app$l lnull$ ?v0) (lhd$ ?v1) (lhd$ ?v0)))) :named a342)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$)) (= (fun_app$a (lappend$a (fun_app$a (lappend$a ?v0) ?v1)) ?v2) (fun_app$a (lappend$a ?v0) (fun_app$a (lappend$a ?v1) ?v2)))) :named a343)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (= (fun_app$ (lappend$ (fun_app$ (lappend$ ?v0) ?v1)) ?v2) (fun_app$ (lappend$ ?v0) (fun_app$ (lappend$ ?v1) ?v2)))) :named a344)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (! (=> (fun_app$bw lnull$a ?v0) (= (fun_app$ (lappend$ ?v0) ?v1) ?v1)) :pattern ((fun_app$ (lappend$ ?v0) ?v1)))) :named a345)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (! (=> (fun_app$l lnull$ ?v0) (= (fun_app$a (lappend$a ?v0) ?v1) ?v1)) :pattern ((fun_app$a (lappend$a ?v0) ?v1)))) :named a346)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (! (=> (fun_app$bw lnull$a ?v0) (= (fun_app$ (lappend$ ?v1) ?v0) ?v1)) :pattern ((fun_app$ (lappend$ ?v1) ?v0)))) :named a347)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (! (=> (fun_app$l lnull$ ?v0) (= (fun_app$a (lappend$a ?v1) ?v0) ?v1)) :pattern ((fun_app$a (lappend$a ?v1) ?v0)))) :named a348)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$bw lnull$a ?v0) (fun_app$bw lnull$a ?v1)) (fun_app$bw lnull$a (fun_app$ (lappend$ ?v0) ?v1)))) :named a349)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (and (fun_app$l lnull$ ?v0) (fun_app$l lnull$ ?v1)) (fun_app$l lnull$ (fun_app$a (lappend$a ?v0) ?v1)))) :named a350)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (=> (or (not (fun_app$bw lnull$a ?v0)) (not (fun_app$bw lnull$a ?v1))) (not (fun_app$bw lnull$a (fun_app$ (lappend$ ?v0) ?v1))))) :named a351)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (or (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) (not (fun_app$l lnull$ (fun_app$a (lappend$a ?v0) ?v1))))) :named a352)) +(assert (! (= (fun_app$ (lappend$ lNil$a) lNil$a) lNil$a) :named a353)) +(assert (! (= (fun_app$a (lappend$a lNil$) lNil$) lNil$) :named a354)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (= (fun_app$ (lappend$ ?v0) ?v1) lNil$a) (and (= ?v0 lNil$a) (= ?v1 lNil$a)))) :named a355)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (= (fun_app$a (lappend$a ?v0) ?v1) lNil$) (and (= ?v0 lNil$) (= ?v1 lNil$)))) :named a356)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (= lNil$a (fun_app$ (lappend$ ?v0) ?v1)) (and (= ?v0 lNil$a) (= ?v1 lNil$a)))) :named a357)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (= lNil$ (fun_app$a (lappend$a ?v0) ?v1)) (and (= ?v0 lNil$) (= ?v1 lNil$)))) :named a358)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (= (fun_app$ (lappend$ ?v0) ?v1) (case_llist$d ?v1 (uwh$ ?v1) ?v0))) :named a359)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (fun_app$a (lappend$a ?v0) ?v1) (fun_app$a (fun_app$cj (case_llist$a ?v1) (uwi$ ?v1)) ?v0))) :named a360)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$)) (! (=> (and (fun_app$bw lnull$a ?v0) (fun_app$bw lnull$a ?v1)) (= (fun_app$ (lappend$ ?v0) ?v1) lNil$a)) :pattern ((fun_app$ (lappend$ ?v0) ?v1)))) :named a361)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (! (=> (and (fun_app$l lnull$ ?v0) (fun_app$l lnull$ ?v1)) (= (fun_app$a (lappend$a ?v0) ?v1) lNil$)) :pattern ((fun_app$a (lappend$a ?v0) ?v1)))) :named a362)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (= (fun_app$ (lappend$ (fun_app$ (lappend$ ?v0) (lCons$a ?v1 lNil$a))) ?v2) (fun_app$ (lappend$ ?v0) (lCons$a ?v1 ?v2)))) :named a363)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (not (fun_app$l lnull$ ?v0)) (= (fun_app$a (lappend$a (ltl$ ?v0)) ?v1) (ltl$ (fun_app$a (lappend$a ?v0) ?v1))))) :named a364)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (or (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) (= (fun_app$a (lappend$a ?v0) ?v1) (lCons$ (fun_app$c (fun_app$ck (case_llist$b (lhd$ ?v1)) uwb$) ?v0) (fun_app$a (fun_app$cj (case_llist$a (fun_app$a (fun_app$cj (case_llist$a undefined$) uvv$) ?v1)) (uwj$ ?v1)) ?v0))))) :named a365)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (or (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) (= (ltl$ (fun_app$a (lappend$a ?v0) ?v1)) (fun_app$a (fun_app$cj (case_llist$a (fun_app$a (fun_app$cj (case_llist$a undefined$) uvv$) ?v1)) (uwj$ ?v1)) ?v0)))) :named a366)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_fun$)) (= (inv_image$ ?v0 ?v1) (collect$ (fun_app$ad uncurry$a (fun_app$z (uwk$ ?v0) ?v1))))) :named a367)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_llist_a_llist_prod_set_fun$)) (= (same_fst$ ?v0 ?v1) (collect$a (fun_app$al uncurry$d (fun_app$aj uncurry$c (fun_app$bt (uwm$ ?v0) ?v1)))))) :named a368)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v3)) (fun_app$bw (fun_app$bx ?v2 (lhd$a ?v3)) ?v3))) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod$)) (=> (and (not (fun_app$bw lnull$a ?v3)) (and (fun_app$i (member$ ?v4) (lset$ (ltl$a ?v3))) (fun_app$bw (fun_app$bx ?v2 ?v4) (ltl$a ?v3)))) (fun_app$bw (fun_app$bx ?v2 ?v4) ?v3))))) (fun_app$bw (fun_app$bx ?v2 ?v0) ?v1))) :named a369)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$) (?v2 A_a_llist_bool_fun_fun$)) (=> (and (member$b ?v0 (lset$a ?v1)) (and (forall ((?v3 A_llist$)) (=> (not (fun_app$l lnull$ ?v3)) (fun_app$l (fun_app$as ?v2 (lhd$ ?v3)) ?v3))) (forall ((?v3 A_llist$) (?v4 A$)) (=> (and (not (fun_app$l lnull$ ?v3)) (and (member$b ?v4 (lset$a (ltl$ ?v3))) (fun_app$l (fun_app$as ?v2 ?v4) (ltl$ ?v3)))) (fun_app$l (fun_app$as ?v2 ?v4) ?v3))))) (fun_app$l (fun_app$as ?v2 ?v0) ?v1))) :named a370)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist_a_llist_fun$)) (= (fun_app$i (member$ (pair$ ?v0 ?v1)) (inv_image$ ?v2 ?v3)) (fun_app$i (member$ (pair$ (fun_app$a ?v3 ?v0) (fun_app$a ?v3 ?v1))) ?v2))) :named a371)) +(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist_a_llist_a_llist_prod_set_fun$)) (=> (and (fun_app$l ?v0 ?v1) (fun_app$i (member$ (pair$ ?v2 ?v3)) (fun_app$n ?v4 ?v1))) (member$a (pair$b (pair$ ?v1 ?v2) (pair$ ?v1 ?v3)) (same_fst$ ?v0 ?v4)))) :named a372)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v0 ?v1)))) :named a373)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v0 ?v1)))) :named a374)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v2 ?v1))))) :named a375)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v2 ?v1))))) :named a376)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v1 (lCons$a ?v0 ?v2)) false)) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (=> (and (= ?v1 (lCons$a ?v2 ?v3)) (fun_app$i (member$ ?v0) (lset$ ?v3))) false)))) false)) :named a377)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_bool_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (fun_app$bw ?v2 (lCons$a ?v0 ?v3))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v4)) (and (not (= ?v0 ?v3)) (fun_app$bw ?v2 ?v4))) (fun_app$bw ?v2 (lCons$a ?v3 ?v4)))))) (fun_app$bw ?v2 ?v1))) :named a378)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_bool_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (fun_app$bw ?v2 (lCons$a ?v0 ?v3))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v4)) (fun_app$bw ?v2 ?v4)) (fun_app$bw ?v2 (lCons$a ?v3 ?v4)))))) (fun_app$bw ?v2 ?v1))) :named a379)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v1 (lCons$a ?v0 ?v2)) false)) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (=> (and (= ?v1 (lCons$a ?v2 ?v3)) (fun_app$i (member$ ?v0) (lset$ ?v3))) false)))) false)) :named a380)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (fun_app$bw (fun_app$bx ?v2 ?v3) (lCons$a ?v3 ?v4))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$) (?v5 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v5) (lset$ ?v4)) (fun_app$bw (fun_app$bx ?v2 ?v5) ?v4)) (fun_app$bw (fun_app$bx ?v2 ?v5) (lCons$a ?v3 ?v4)))))) (fun_app$bw (fun_app$bx ?v2 ?v0) ?v1))) :named a381)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (member$ ?v0) (lset$ (ltl$a ?v1))) (fun_app$i (member$ ?v0) (lset$ ?v1)))) :named a382)) +(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (=> (member$b ?v0 (lset$a (ltl$ ?v1))) (member$b ?v0 (lset$a ?v1)))) :named a383)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (= (fun_app$i (member$ ?v0) (lset$ ?v1)) (fun_app$bw (lmember$ ?v0) ?v1))) :named a384)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$)) (=> (and (not (fun_app$bw lnull$a ?v0)) (fun_app$i (member$ ?v1) (lset$ (ltl$a ?v0)))) (fun_app$i (member$ ?v1) (lset$ ?v0)))) :named a385)) +(assert (! (forall ((?v0 A_llist$) (?v1 A$)) (=> (and (not (fun_app$l lnull$ ?v0)) (member$b ?v1 (lset$a (ltl$ ?v0)))) (member$b ?v1 (lset$a ?v0)))) :named a386)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v0)) (fun_app$i (member$ (lhd$a ?v0)) (lset$ ?v0)))) :named a387)) +(assert (! (forall ((?v0 A_llist$)) (=> (not (fun_app$l lnull$ ?v0)) (member$b (lhd$ ?v0) (lset$a ?v0)))) :named a388)) +(assert (! (forall ((?v0 A_llist$)) (= (lhd$ ?v0) (fun_app$c (fun_app$ck (case_llist$b undefined$a) uwb$) ?v0))) :named a389)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (lex_prod$ ?v0 ?v1) (collect$a (fun_app$al uncurry$d (fun_app$aj uncurry$c (fun_app$bq (uwo$ ?v0) ?v1)))))) :named a390)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (exists ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$)) (and (= ?v1 (fun_app$ (lappend$ ?v2) (lCons$a ?v0 ?v3))) (and (lfinite$ ?v2) (not (fun_app$i (member$ ?v0) (lset$ ?v2)))))))) :named a391)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (exists ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$)) (and (= ?v1 (fun_app$ (lappend$ ?v2) (lCons$a ?v0 ?v3))) (lfinite$ ?v2))))) :named a392)) +(assert (! (forall ((?v0 A_llist$)) (= (lfinite$a (ltl$ ?v0)) (lfinite$a ?v0))) :named a393)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist_a_llist_prod_set$) (?v5 A_llist_a_llist_prod_set$)) (= (member$a (pair$b (pair$ ?v0 ?v1) (pair$ ?v2 ?v3)) (lex_prod$ ?v4 ?v5)) (or (fun_app$i (member$ (pair$ ?v0 ?v2)) ?v4) (and (= ?v0 ?v2) (fun_app$i (member$ (pair$ ?v1 ?v3)) ?v5))))) :named a394)) +(assert (! (forall ((?v0 A_llist$)) (=> (fun_app$l lnull$ ?v0) (lfinite$a ?v0))) :named a395)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist_bool_fun$)) (=> (and (lfinite$a ?v0) (and (forall ((?v2 A_llist$)) (=> (fun_app$l lnull$ ?v2) (fun_app$l ?v1 ?v2))) (forall ((?v2 A_llist$)) (=> (and (lfinite$a ?v2) (and (not (fun_app$l lnull$ ?v2)) (fun_app$l ?v1 (ltl$ ?v2)))) (fun_app$l ?v1 ?v2))))) (fun_app$l ?v1 ?v0))) :named a396)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (= (fun_app$i (member$ ?v0) (lset$ (fun_app$ (lappend$ ?v1) ?v2))) (or (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (lfinite$ ?v1) (fun_app$i (member$ ?v0) (lset$ ?v2)))))) :named a397)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$)) (= (collect$ (fun_app$t (uwp$ ?v0) ?v1)) (sup$ (collect$ ?v0) (collect$ ?v1)))) :named a398)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (sup$ ?v0 ?v1) (collect$ (fun_app$s (uwq$ ?v0) ?v1)))) :named a399)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_a_bool_fun_fun$)) (=> (and (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (forall ((?v4 A_llist$) (?v5 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v4) ?v5) (and (= (fun_app$l lnull$ ?v4) (fun_app$l lnull$ ?v5)) (=> (and (not (fun_app$l lnull$ ?v4)) (not (fun_app$l lnull$ ?v5))) (and (fun_app$k (fun_app$co ?v3 (lhd$ ?v4)) (lhd$ ?v5)) (fun_app$l (fun_app$m ?v0 (ltl$ ?v4)) (ltl$ ?v5)))))))) (fun_app$l (fun_app$m (llist_all2$ ?v3) ?v1) ?v2))) :named a400)) +(assert (! (forall ((?v0 A_a_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (= (fun_app$l (fun_app$m (llist_all2$ ?v0) ?v1) ?v2) (and (= (fun_app$l lnull$ ?v1) (fun_app$l lnull$ ?v2)) (=> (and (not (fun_app$l lnull$ ?v1)) (not (fun_app$l lnull$ ?v2))) (and (fun_app$k (fun_app$co ?v0 (lhd$ ?v1)) (lhd$ ?v2)) (fun_app$l (fun_app$m (llist_all2$ ?v0) (ltl$ ?v1)) (ltl$ ?v2))))))) :named a401)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (=> (fun_app$i (member$ (pair$ ?v2 ?v3)) ?v0) (fun_app$i (member$ (pair$ ?v2 ?v3)) ?v1))) (fun_app$i (less_eq$ ?v0) ?v1))) :named a402)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (and (fun_app$bw (fun_app$by (llist_all2$a ?v0) ?v1) ?v2) (forall ((?v4 A_llist_a_llist_prod$) (?v5 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v4) (lset$ ?v1)) (and (fun_app$i (member$ ?v5) (lset$ ?v2)) (fun_app$h (fun_app$r ?v0 ?v4) ?v5))) (fun_app$h (fun_app$r ?v3 ?v4) ?v5)))) (fun_app$bw (fun_app$by (llist_all2$a ?v3) ?v1) ?v2))) :named a403)) +(assert (! (forall ((?v0 A_llist$)) (less_eq$a (lset$a (ltl$ ?v0)) (lset$a ?v0))) :named a404)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod_bool_fun$)) (= (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$t (uwr$ ?v1) ?v2))) (and (fun_app$i (less_eq$ ?v0) (collect$ ?v1)) (fun_app$i (less_eq$ ?v0) (collect$ ?v2))))) :named a405)) +(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist_a_llist_prod_bool_fun$)) (=> (and (fun_app$i (member$ ?v0) ?v1) (fun_app$i (less_eq$ ?v1) (collect$ (fun_app$t (uws$ ?v2) ?v3)))) (fun_app$h ?v3 ?v0))) :named a406)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_bool_fun$) (?v3 A_llist_a_llist_prod_bool_fun$)) (=> (and (fun_app$i (less_eq$ ?v0) ?v1) (forall ((?v4 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v4) ?v0) (fun_app$h ?v2 ?v4)) (fun_app$h ?v3 ?v4)))) (fun_app$i (less_eq$ (collect$ (fun_app$t (uws$ ?v0) ?v2))) (collect$ (fun_app$t (uws$ ?v1) ?v3))))) :named a407)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (fun_app$i (less_eq$ ?v0) ?v1) (fun_app$bk (less_eq$b (uui$ ?v0)) (uui$ ?v1)))) :named a408)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (fun_app$bk (less_eq$b (uui$ ?v0)) (uui$ ?v1)) (fun_app$i (less_eq$ ?v0) ?v1))) :named a409)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (less_eq$c (uvz$ ?v0) (uvz$ ?v1)) (fun_app$i (less_eq$ ?v0) ?v1))) :named a410)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist$)) (=> (and (fun_app$i (member$ (pair$ ?v0 ?v1)) ?v2) (= ?v3 ?v1)) (fun_app$i (member$ (pair$ ?v0 ?v3)) ?v2))) :named a411)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_bool_fun$)) (fun_app$i (less_eq$ (collect$ (fun_app$t (uws$ ?v0) ?v1))) ?v0)) :named a412)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_bool_fun$)) (=> (fun_app$i (less_eq$ ?v0) ?v1) (= (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$t (uws$ ?v1) ?v2))) (forall ((?v3 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v3) ?v0) (fun_app$h ?v2 ?v3)))))) :named a413)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_bool_fun_fun$)) (=> (less_eq$c ?v0 ?v1) (fun_app$i (less_eq$ (collect$ (fun_app$ad uncurry$a ?v0))) (collect$ (fun_app$ad uncurry$a ?v1))))) :named a414)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (=> (and (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$ad uncurry$a (in_rel$ ?v1)))) (=> (fun_app$i (less_eq$ ?v0) ?v1) false)) false)) :named a415)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (in_rel$ ?v0) ?v1) ?v2) (fun_app$i (member$ (pair$ ?v1 ?v2)) ?v0)) :pattern ((fun_app$l (fun_app$m (in_rel$ ?v0) ?v1) ?v2)))) :named a416)) +(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$)) (= (in_rel$ (collect$ (fun_app$ad uncurry$a ?v0))) ?v0)) :named a417)) +(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (=> (fun_app$i (less_eq$ ?v0) ?v1) (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$ad uncurry$a (in_rel$ ?v1)))))) :named a418)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist_a_llist_prod_a_llist_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist$) (?v4 A_llist_a_llist_prod_a_llist_fun$) (?v5 A_llist_a_llist_prod_set$)) (=> (and (= ?v0 (fun_app$cp ?v1 ?v2)) (and (= ?v3 (fun_app$cp ?v4 ?v2)) (fun_app$i (member$ ?v2) ?v5))) (fun_app$i (member$ (pair$ ?v0 ?v3)) (image2$ ?v5 ?v1 ?v4)))) :named a419)) +(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (the$ (fun_app$ad uncurry$a (fun_app$aa (uwt$ ?v0) ?v1))) (pair$ ?v0 ?v1))) :named a420)) +(check-sat) + diff --git a/test/regress/regress1/quantifiers/ext-ex-deq-trigger.smt2 b/test/regress/regress1/quantifiers/ext-ex-deq-trigger.smt2 new file mode 100644 index 000000000..f6f96fe02 --- /dev/null +++ b/test/regress/regress1/quantifiers/ext-ex-deq-trigger.smt2 @@ -0,0 +1,26 @@ +; COMMAND-LINE: --relational-triggers +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) + +(declare-sort U 0) + +(declare-const k U) +(declare-const ff U) +(declare-const ffk U) +(declare-fun fun1 (Int) Int) +(declare-fun fun2 (Int) Int) +(declare-fun c (U U) U) +(declare-fun app (U Int) Int) + +(assert (forall ((f U) (g U)) (=> (forall ((x Int)) (= (app f x) (app g x))) (= f g)) )) + +(assert (forall ((x Int)) (= (app ff x) (+ (fun1 x) (fun2 x))))) +(assert (forall ((x Int)) (= (app ffk x) (+ (fun1 (app k x)) (fun2 (app k x)))))) + +(assert (forall ((f U) (g U) (x Int)) (= (app (c f g) x) (app f (app g x))))) + +(assert (not (= (c ff k) ffk))) + +(check-sat) + diff --git a/test/regress/regress1/quantifiers/extract-nproc.smt2 b/test/regress/regress1/quantifiers/extract-nproc.smt2 new file mode 100644 index 000000000..6072776dc --- /dev/null +++ b/test/regress/regress1/quantifiers/extract-nproc.smt2 @@ -0,0 +1,9 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-rm-extract +; EXPECT: sat +(set-logic BV) +(declare-fun k_3 () (_ BitVec 8)) +(declare-fun k_4 () (_ BitVec 8)) +(declare-fun k_5 () (_ BitVec 8)) +(assert +(forall ((x (_ BitVec 8))) (or (= k_5 x) (not (= k_3 (bvadd (concat #b0000 ((_ extract 7 4) x)) #b01000001))) (not (= k_4 (bvadd (concat #b0000 ((_ extract 3 0) x)) #b01000001)))) )) +(check-sat) diff --git a/test/regress/regress1/quantifiers/florian-case-ax.smt2 b/test/regress/regress1/quantifiers/florian-case-ax.smt2 new file mode 100644 index 000000000..35ebb28e9 --- /dev/null +++ b/test/regress/regress1/quantifiers/florian-case-ax.smt2 @@ -0,0 +1,168 @@ +(set-logic AUFLIA) +(set-info :status unsat) +(declare-sort U 0) +(declare-fun A (U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U U U + U U + U) (Array Int U)) + +(assert + (forall ((v_184 U) (v_185 U) + (v_186 U) (v_187 U) + (v_188 U) (v_189 U) + (v_190 U) (v_191 U) + (v_192 U) (v_193 U) + (v_194 U) (v_195 U) + (v_196 U) (v_197 U) + (v_198 U) (v_199 U) + (v_200 U) (v_201 U) + (v_202 U) (v_203 U) + (v_204 U) (v_205 U) + (v_206 U) (v_207 U) + (v_208 U) (v_209 U) + (v_210 U) (v_211 U) + (v_212 U) (v_213 U) + (v_214 U) (v_215 U) + (v_216 U) (v_217 U) + (v_218 U) (v_219 U) + (v_220 U) (v_221 U) + (v_222 U) (v_223 U) + (v_224 U) (v_225 U) + (v_226 U) (v_227 U) + (v_228 U) (v_229 U) + (v_230 U) (v_231 U) + (v_232 U) (v_233 U) + (v_234 U) (v_235 U) + (v_236 U) (v_237 U) + (v_238 U) (v_239 U) + (v_240 U) (v_241 U) (v_242 Int)) + (let ((v_183 (A v_184 v_185 v_186 v_187 + v_188 v_189 v_190 v_191 v_192 + v_193 v_194 v_195 v_196 v_197 + v_198 v_199 v_200 v_201 v_202 + v_203 v_204 v_205 v_206 v_207 + v_208 v_209 v_210 v_211 v_212 + v_213 v_214 v_215 v_216 v_217 + v_218 v_219 v_220 v_221 v_222 + v_223 v_224 v_225 v_226 v_227 + v_228 v_229 v_230 v_231 v_232 + v_233 v_234 v_235 v_236 v_237 + v_238 v_239 v_240 v_241))) + (ite (= v_242 59) (= (select v_183 v_242) v_240) + (ite (= v_242 58) (= (select v_183 v_242) v_239) + (ite (= v_242 57) (= (select v_183 v_242) v_238) + (ite (= v_242 56) (= (select v_183 v_242) v_237) + (ite (= v_242 55) (= (select v_183 v_242) v_236) + (ite (= v_242 54) (= (select v_183 v_242) v_235) + (ite (= v_242 53) (= (select v_183 v_242) v_234) + (ite (= v_242 52) (= (select v_183 v_242) v_233) + (ite (= v_242 51) (= (select v_183 v_242) v_232) + (ite (= v_242 50) (= (select v_183 v_242) v_231) + (ite (= v_242 49) (= (select v_183 v_242) v_230) + (ite (= v_242 48) (= (select v_183 v_242) v_229) + (ite (= v_242 47) (= (select v_183 v_242) v_228) + (ite (= v_242 46) (= (select v_183 v_242) v_227) + (ite (= v_242 45) (= (select v_183 v_242) v_226) + (ite (= v_242 44) (= (select v_183 v_242) v_225) + (ite (= v_242 43) (= (select v_183 v_242) v_224) + (ite (= v_242 41) (= (select v_183 v_242) v_223) + (ite (= v_242 40) (= (select v_183 v_242) v_222) + (ite (= v_242 39) (= (select v_183 v_242) v_221) + (ite (= v_242 37) (= (select v_183 v_242) v_220) + (ite (= v_242 36) (= (select v_183 v_242) v_219) + (ite (= v_242 34) (= (select v_183 v_242) v_218) + (ite (= v_242 33) (= (select v_183 v_242) v_217) + (ite (= v_242 32) (= (select v_183 v_242) v_216) + (ite (= v_242 31) (= (select v_183 v_242) v_215) + (ite (= v_242 30) (= (select v_183 v_242) v_214) + (ite (= v_242 29) (= (select v_183 v_242) v_213) + (ite (= v_242 28) (= (select v_183 v_242) v_212) + (ite (= v_242 27) (= (select v_183 v_242) v_211) + (ite (= v_242 26) (= (select v_183 v_242) v_210) + (ite (= v_242 25) (= (select v_183 v_242) v_209) + (ite (= v_242 24) (= (select v_183 v_242) v_208) + (ite (= v_242 23) (= (select v_183 v_242) v_207) + (ite (= v_242 22) (= (select v_183 v_242) v_206) + (ite (= v_242 21) (= (select v_183 v_242) v_205) + (ite (= v_242 20) (= (select v_183 v_242) v_204) + (ite (= v_242 19) (= (select v_183 v_242) v_203) + (ite (= v_242 18) (= (select v_183 v_242) v_202) + (ite (= v_242 17) (= (select v_183 v_242) v_201) + (ite (= v_242 16) (= (select v_183 v_242) v_200) + (ite (= v_242 15) (= (select v_183 v_242) v_199) + (ite (= v_242 14) (= (select v_183 v_242) v_198) + (ite (= v_242 13) (= (select v_183 v_242) v_197) + (ite (= v_242 12) (= (select v_183 v_242) v_196) + (ite (= v_242 11) (= (select v_183 v_242) v_195) + (ite (= v_242 10) (= (select v_183 v_242) v_194) + (ite (= v_242 9) (= (select v_183 v_242) v_193) + (ite (= v_242 8) (= (select v_183 v_242) v_192) + (ite (= v_242 7) (= (select v_183 v_242) v_191) + (ite (= v_242 6) (= (select v_183 v_242) v_190) + (ite (= v_242 5) (= (select v_183 v_242) v_189) + (ite (= v_242 4) (= (select v_183 v_242) v_188) + (ite (= v_242 3) (= (select v_183 v_242) v_187) + (ite (= v_242 2) (= (select v_183 v_242) v_186) + (ite (= v_242 1) (= (select v_183 v_242) v_185) + (ite (= v_242 0) (= (select v_183 v_242) v_184) + (= (select v_183 v_242) v_241))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +(declare-const c_184 U) (declare-const c_185 U) +(declare-const c_186 U) (declare-const c_187 U) +(declare-const c_188 U) (declare-const c_189 U) +(declare-const c_190 U) (declare-const c_191 U) +(declare-const c_192 U) (declare-const c_193 U) +(declare-const c_194 U) (declare-const c_195 U) +(declare-const c_196 U) (declare-const c_197 U) +(declare-const c_198 U) (declare-const c_199 U) +(declare-const c_200 U) (declare-const c_201 U) +(declare-const c_202 U) (declare-const c_203 U) +(declare-const c_204 U) (declare-const c_205 U) +(declare-const c_206 U) (declare-const c_207 U) +(declare-const c_208 U) (declare-const c_209 U) +(declare-const c_210 U) (declare-const c_211 U) +(declare-const c_212 U) (declare-const c_213 U) +(declare-const c_214 U) (declare-const c_215 U) +(declare-const c_216 U) (declare-const c_217 U) +(declare-const c_218 U) (declare-const c_219 U) +(declare-const c_220 U) (declare-const c_221 U) +(declare-const c_222 U) (declare-const c_223 U) +(declare-const c_224 U) (declare-const c_225 U) +(declare-const c_226 U) (declare-const c_227 U) +(declare-const c_228 U) (declare-const c_229 U) +(declare-const c_230 U) (declare-const c_231 U) +(declare-const c_232 U) (declare-const c_233 U) +(declare-const c_234 U) (declare-const c_235 U) +(declare-const c_236 U) (declare-const c_237 U) +(declare-const c_238 U) (declare-const c_239 U) +(declare-const c_240 U) (declare-const c_241 U) + +(declare-fun b () Int) +(declare-fun c () U) +(assert (not (= (select (A c_184 c_185 c_186 c_187 + c_188 c_189 c_190 c_191 c_192 + c_193 c_194 c_195 c_196 c_197 + c_198 c_199 c_200 c_201 c_202 + c_203 c_204 c_205 c_206 c_207 + c_208 c_209 c_210 c_211 c_212 + c_213 c_214 c_215 c_216 c_217 + c_218 c_219 c_220 c_221 c_222 + c_223 c_224 c_225 c_226 c_227 + c_228 c_229 c_230 c_231 c_232 + c_233 c_234 c_235 c_236 c_237 + c_238 c_239 c_240 c_241) b) c))) +(assert (and (= b 28) (= c c_212))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/gauss_init_0030.fof.smt2 b/test/regress/regress1/quantifiers/gauss_init_0030.fof.smt2 new file mode 100644 index 000000000..e9f0490a6 --- /dev/null +++ b/test/regress/regress1/quantifiers/gauss_init_0030.fof.smt2 @@ -0,0 +1,61 @@ +(set-logic AUFLIRA) +(set-info :source | +NASA benchmarks from "Using Automated Theorem Provers to Certify Auto-generated +Aerospace Software", IJCAR 2004. Translated from TPTP format by Yeting Ge and +Clark Barrett + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun def () Real) +(declare-fun init () Real) +(declare-fun loopcounter () Int) +(declare-fun pv1403 () Real) +(declare-fun s_best7 () Int) +(declare-fun s_best7_init () Real) +(declare-fun s_sworst7 () Int) +(declare-fun s_sworst7_init () Real) +(declare-fun s_values7_init () (Array Int Real)) +(declare-fun s_worst7 () Int) +(declare-fun s_worst7_init () Real) +(declare-fun simplex7_init () (Array Int (Array Int Real))) +(declare-fun tptp_float_0_001 () Real) +(declare-fun use () Real) +(declare-fun uniform_int_rnd (Int Int) Int) +(declare-fun abs_ (Real) Real) +(declare-fun log (Real) Real) +(declare-fun exp (Real) Real) +(declare-fun cos (Real) Real) +(declare-fun sin (Real) Real) +(declare-fun sqrt (Real) Real) +(declare-fun divide (Real Real) Real) +(declare-fun cond (Int Real Real) Real) +(declare-fun tptp_term_equal (Real Real) Int) +(declare-fun tptp_term_equals (Real Real) Int) +(declare-fun tptp_term_and (Real Real) Int) +(declare-fun sum (Int Int Real) Real) +(declare-fun dim (Int Int) Int) +(declare-fun trans ((Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun inv ((Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_mmul ((Array Int (Array Int Real)) (Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_madd ((Array Int (Array Int Real)) (Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_msub ((Array Int (Array Int Real)) (Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_const_array1 (Int Real) (Array Int Real)) +(declare-fun tptp_const_array2 (Int Int Real) (Array Int (Array Int Real))) +(assert (forall ((?X_0 Int) (?C_1 Int)) (=> (>= ?X_0 0) (<= (uniform_int_rnd ?C_1 ?X_0) ?X_0)))) +(assert (forall ((?X_2 Int) (?C_3 Int)) (=> (>= ?X_2 0) (>= (uniform_int_rnd ?C_3 ?X_2) 0)))) +(assert (forall ((?I_4 Int) (?L_5 Int) (?U_6 Int) (?Val_7 Real)) (=> (and (<= ?L_5 ?I_4) (<= ?I_4 ?U_6)) (= (select (tptp_const_array1 (dim ?L_5 ?U_6) ?Val_7) ?I_4) ?Val_7)))) +(assert (forall ((?I_8 Int) (?L1_9 Int) (?U1_10 Int) (?J_11 Int) (?L2_12 Int) (?U2_13 Int) (?Val_14 Real)) (=> (and (and (and (<= ?L1_9 ?I_8) (<= ?I_8 ?U1_10)) (<= ?L2_12 ?J_11)) (<= ?J_11 ?U2_13)) (= (select (select (tptp_const_array2 (dim ?L1_9 ?U1_10) (dim ?L2_12 ?U2_13) ?Val_14) ?I_8) ?J_11) ?Val_14)))) +(assert (forall ((?I0_15 Int) (?J0_16 Int) (?A_17 (Array Int (Array Int Real))) (?B_18 (Array Int (Array Int Real))) (?N_19 Int)) (let ((?v_0 (tptp_mmul ?A_17 (tptp_mmul ?B_18 (trans ?A_17))))) (=> (and (and (and (and (>= ?I0_15 0) (<= ?I0_15 ?N_19)) (>= ?J0_16 0)) (<= ?J0_16 ?N_19)) (= (select (select ?B_18 ?I0_15) ?J0_16) (select (select ?B_18 ?J0_16) ?I0_15))) (= (select (select ?v_0 ?I0_15) ?J0_16) (select (select ?v_0 ?J0_16) ?I0_15)))))) +(assert (forall ((?I0_20 Int) (?J0_21 Int) (?I_22 Int) (?J_23 Int) (?A_24 (Array Int (Array Int Real))) (?B_25 (Array Int (Array Int Real))) (?N_26 Int) (?M_27 Int)) (let ((?v_0 (tptp_mmul ?A_24 (tptp_mmul ?B_25 (trans ?A_24))))) (=> (and (and (and (and (and (and (and (and (>= ?I0_20 0) (<= ?I0_20 ?N_26)) (>= ?J0_21 0)) (<= ?J0_21 ?N_26)) (>= ?I_22 0)) (<= ?I_22 ?M_27)) (>= ?J_23 0)) (<= ?J_23 ?M_27)) (= (select (select ?B_25 ?I_22) ?J_23) (select (select ?B_25 ?J_23) ?I_22))) (= (select (select ?v_0 ?I0_20) ?J0_21) (select (select ?v_0 ?J0_21) ?I0_20)))))) +(assert (forall ((?I_28 Int) (?J_29 Int) (?A_30 (Array Int (Array Int Real))) (?B_31 (Array Int (Array Int Real))) (?N_32 Int)) (let ((?v_0 (tptp_madd ?A_30 ?B_31))) (=> (and (and (and (and (and (>= ?I_28 0) (<= ?I_28 ?N_32)) (>= ?J_29 0)) (<= ?J_29 ?N_32)) (= (select (select ?A_30 ?I_28) ?J_29) (select (select ?A_30 ?J_29) ?I_28))) (= (select (select ?B_31 ?I_28) ?J_29) (select (select ?B_31 ?J_29) ?I_28))) (= (select (select ?v_0 ?I_28) ?J_29) (select (select ?v_0 ?J_29) ?I_28)))))) +(assert (forall ((?I_33 Int) (?J_34 Int) (?A_35 (Array Int (Array Int Real))) (?B_36 (Array Int (Array Int Real))) (?N_37 Int)) (let ((?v_0 (tptp_msub ?A_35 ?B_36))) (=> (and (and (and (and (and (>= ?I_33 0) (<= ?I_33 ?N_37)) (>= ?J_34 0)) (<= ?J_34 ?N_37)) (= (select (select ?A_35 ?I_33) ?J_34) (select (select ?A_35 ?J_34) ?I_33))) (= (select (select ?B_36 ?I_33) ?J_34) (select (select ?B_36 ?J_34) ?I_33))) (= (select (select ?v_0 ?I_33) ?J_34) (select (select ?v_0 ?J_34) ?I_33)))))) +(assert (forall ((?I_38 Int) (?J_39 Int) (?A_40 (Array Int (Array Int Real))) (?N_41 Int)) (let ((?v_0 (trans ?A_40))) (=> (and (and (and (and (>= ?I_38 0) (<= ?I_38 ?N_41)) (>= ?J_39 0)) (<= ?J_39 ?N_41)) (= (select (select ?A_40 ?I_38) ?J_39) (select (select ?A_40 ?J_39) ?I_38))) (= (select (select ?v_0 ?I_38) ?J_39) (select (select ?v_0 ?J_39) ?I_38)))))) +(assert (forall ((?I_42 Int) (?J_43 Int) (?A_44 (Array Int (Array Int Real))) (?N_45 Int)) (let ((?v_0 (inv ?A_44))) (=> (and (and (and (and (>= ?I_42 0) (<= ?I_42 ?N_45)) (>= ?J_43 0)) (<= ?J_43 ?N_45)) (= (select (select ?A_44 ?I_42) ?J_43) (select (select ?A_44 ?J_43) ?I_42))) (= (select (select ?v_0 ?I_42) ?J_43) (select (select ?v_0 ?J_43) ?I_42)))))) +(assert (forall ((?I0_46 Int) (?J0_47 Int) (?I_48 Int) (?J_49 Int) (?A_50 (Array Int (Array Int Real))) (?B_51 (Array Int (Array Int Real))) (?C_52 (Array Int (Array Int Real))) (?D_53 (Array Int (Array Int Real))) (?E_54 (Array Int (Array Int Real))) (?F_55 (Array Int (Array Int Real))) (?N_56 Int) (?M_57 Int)) (let ((?v_0 (tptp_madd ?A_50 (tptp_mmul ?B_51 (tptp_mmul (tptp_madd (tptp_mmul ?C_52 (tptp_mmul ?D_53 (trans ?C_52))) (tptp_mmul ?E_54 (tptp_mmul ?F_55 (trans ?E_54)))) (trans ?B_51)))))) (=> (and (and (and (and (and (and (and (and (and (and (>= ?I0_46 0) (<= ?I0_46 ?N_56)) (>= ?J0_47 0)) (<= ?J0_47 ?N_56)) (>= ?I_48 0)) (<= ?I_48 ?M_57)) (>= ?J_49 0)) (<= ?J_49 ?M_57)) (= (select (select ?D_53 ?I_48) ?J_49) (select (select ?D_53 ?J_49) ?I_48))) (= (select (select ?A_50 ?I0_46) ?J0_47) (select (select ?A_50 ?J0_47) ?I0_46))) (= (select (select ?F_55 ?I0_46) ?J0_47) (select (select ?F_55 ?J0_47) ?I0_46))) (= (select (select ?v_0 ?I0_46) ?J0_47) (select (select ?v_0 ?J0_47) ?I0_46)))))) +(assert (forall ((?Body_58 Real)) (= (sum 0 (- 1) ?Body_58) 0.0))) +(assert (not (= def use))) +(assert (let ((?v_0 (not (<= tptp_float_0_001 pv1403))) (?v_1 (= s_best7_init init)) (?v_3 (= s_sworst7_init init)) (?v_4 (= s_worst7_init init)) (?v_5 (>= s_best7 0)) (?v_6 (>= s_sworst7 0)) (?v_7 (>= s_worst7 0)) (?v_8 (<= s_best7 3)) (?v_9 (<= s_sworst7 3)) (?v_10 (<= s_worst7 3)) (?v_2 (> loopcounter 0))) (not (=> (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and ?v_0 (forall ((?A_59 Int)) (=> (and (>= ?A_59 0) (<= ?A_59 2)) (forall ((?B_60 Int)) (=> (and (>= ?B_60 0) (<= ?B_60 3)) (= (select (select simplex7_init ?B_60) ?A_59) init)))))) (forall ((?C_61 Int)) (=> (and (>= ?C_61 0) (<= ?C_61 3)) (= (select s_values7_init ?C_61) init)))) (=> ?v_0 ?v_1)) (=> ?v_0 ?v_3)) (=> ?v_0 ?v_4)) (=> ?v_0 ?v_5)) (=> ?v_0 ?v_6)) (=> ?v_0 ?v_7)) (=> ?v_0 ?v_8)) (=> ?v_0 ?v_9)) (=> ?v_0 ?v_10)) (=> ?v_2 ?v_1)) (=> ?v_2 ?v_3)) (=> ?v_2 ?v_4)) (=> ?v_2 (= (select s_values7_init s_best7) init))) (=> ?v_2 (= (select s_values7_init s_sworst7) init))) (=> ?v_2 (= (select s_values7_init s_worst7) init))) (=> ?v_2 ?v_5)) (=> ?v_2 ?v_6)) (=> ?v_2 ?v_7)) (=> ?v_2 ?v_8)) (=> ?v_2 ?v_9)) (=> ?v_2 ?v_10)) (= (select (select simplex7_init s_best7) 0) init))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/inst-max-level-segf.smt2 b/test/regress/regress1/quantifiers/inst-max-level-segf.smt2 new file mode 100644 index 000000000..d85f3d094 --- /dev/null +++ b/test/regress/regress1/quantifiers/inst-max-level-segf.smt2 @@ -0,0 +1,326 @@ +; COMMAND-LINE: --inst-max-level=0 --simplification=none +; EXPECT: unsat +(set-logic UF) +(set-info :status unsat) +(declare-sort Node 0) +(declare-sort GrassPat 0) +(declare-sort GrassArray 1) +(declare-sort ArrayCell 1) +(declare-sort Loc 1) +(declare-sort Set 1) +(declare-sort Map 2) +(declare-sort GrassByte 0) +(declare-fun grass_null$0 () (Loc Node)) +(declare-fun grass_read$0 ((Map (Loc Node) (Loc Node)) (Loc Node)) + (Loc Node)) +(declare-fun grass_emptyset$0 () (Set (Loc Node))) +(declare-fun grass_singleton$0 ((Loc Node)) (Set (Loc Node))) +(declare-fun grass_union$0 ((Set (Loc Node)) (Set (Loc Node))) + (Set (Loc Node))) +(declare-fun grass_intersection$0 ((Set (Loc Node)) (Set (Loc Node))) + (Set (Loc Node))) +(declare-fun grass_setminus$0 ((Set (Loc Node)) (Set (Loc Node))) + (Set (Loc Node))) +(declare-fun grass_Btwn$0 ((Map (Loc Node) (Loc Node)) (Loc Node) (Loc Node) + (Loc Node)) Bool) +(declare-fun grass_member$0 ((Loc Node) (Set (Loc Node))) Bool) +(declare-fun grass_known$0 ((Map (Loc Node) (Loc Node))) GrassPat) +(declare-fun grass_known$1 (Bool) GrassPat) +(declare-fun Alloc_Node$0 () (Set (Loc Node))) +(declare-fun FP_Caller_Node$0 () (Set (Loc Node))) +(declare-fun FP_Caller_Node_1$0 () (Set (Loc Node))) +(declare-fun FP_Caller_final_Node_2$0 () (Set (Loc Node))) +(declare-fun FP_Node$0 () (Set (Loc Node))) +(declare-fun Label$0 () Bool) +(declare-fun Label_1$0 () Bool) +(declare-fun Label_2$0 () Bool) +(declare-fun Label_3$0 () Bool) +(declare-fun elt$0 () (Loc Node)) +(declare-fun lseg$0 ((Map (Loc Node) (Loc Node)) (Loc Node) (Loc Node) + (Set (Loc Node))) Bool) +(declare-fun lst$0 () (Loc Node)) +(declare-fun next$0 () (Map (Loc Node) (Loc Node))) +(declare-fun res_2$0 () (Loc Node)) +(declare-fun set_compr$0 ((Map (Loc Node) (Loc Node)) (Loc Node) (Loc Node)) + (Set (Loc Node))) +(declare-fun sk_?X$0 () (Set (Loc Node))) +(declare-fun sk_?X_1$0 () (Set (Loc Node))) +(declare-fun sk_?X_2$0 () (Set (Loc Node))) +(declare-fun sk_?X_3$0 () (Set (Loc Node))) +(declare-fun sk_?X_4$0 () (Set (Loc Node))) +(declare-fun sk_?e$0 () (Loc Node)) + +(assert (not (grass_member$0 grass_null$0 Alloc_Node$0))) +(assert + (and + (or + (or + (and (and (grass_member$0 sk_?e$0 sk_?X_4$0) Label_1$0) + (and + (not + (grass_member$0 sk_?e$0 + (set_compr$0 next$0 res_2$0 grass_null$0))) + Label_1$0)) + (and + (and + (grass_member$0 sk_?e$0 + (set_compr$0 next$0 res_2$0 grass_null$0)) + Label_1$0) + (and (not (grass_member$0 sk_?e$0 sk_?X_4$0)) Label_1$0))) + (and + (not (grass_Btwn$0 next$0 res_2$0 grass_null$0 grass_null$0)) + Label$0)) + Label_2$0)) +(assert (forall ((x (Loc Node))) (not (grass_member$0 x grass_emptyset$0)))) +(assert + (forall ((y (Loc Node)) (x (Loc Node))) + (or (and (= x y) (grass_member$0 x (grass_singleton$0 y))) + (and (not (= x y)) + (not (grass_member$0 x (grass_singleton$0 y))))))) +(assert + (forall ((x (Loc Node))) + (or + (and (grass_member$0 x FP_Caller_Node$0) + (grass_member$0 x + (grass_setminus$0 FP_Caller_Node$0 FP_Node$0)) + (not (grass_member$0 x FP_Node$0))) + (and + (or (grass_member$0 x FP_Node$0) + (not (grass_member$0 x FP_Caller_Node$0))) + (not + (grass_member$0 x + (grass_setminus$0 FP_Caller_Node$0 FP_Node$0))))))) +(assert + (forall ((x (Loc Node))) + (or + (and (grass_member$0 x Alloc_Node$0) + (grass_member$0 x + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0)) + (not (grass_member$0 x Alloc_Node$0))) + (and + (or (grass_member$0 x Alloc_Node$0) + (not (grass_member$0 x Alloc_Node$0))) + (not + (grass_member$0 x + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0))))))) +(assert + (forall ((x (Loc Node))) + (or + (and (grass_member$0 x Alloc_Node$0) + (grass_member$0 x FP_Node$0) + (grass_member$0 x + (grass_intersection$0 Alloc_Node$0 FP_Node$0))) + (and + (or (not (grass_member$0 x Alloc_Node$0)) + (not (grass_member$0 x FP_Node$0))) + (not + (grass_member$0 x + (grass_intersection$0 Alloc_Node$0 FP_Node$0))))))) +(assert + (forall ((x (Loc Node))) + (or + (and (grass_member$0 x sk_?X$0) + (grass_member$0 x sk_?X_1$0) + (grass_member$0 x + (grass_intersection$0 sk_?X$0 sk_?X_1$0))) + (and + (or (not (grass_member$0 x sk_?X$0)) + (not (grass_member$0 x sk_?X_1$0))) + (not + (grass_member$0 x + (grass_intersection$0 sk_?X$0 sk_?X_1$0))))))) +(assert + (forall ((x (Loc Node))) + (or + (and + (grass_member$0 x + (grass_union$0 + (grass_intersection$0 Alloc_Node$0 FP_Node$0) + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0))) + (or + (grass_member$0 x + (grass_intersection$0 Alloc_Node$0 FP_Node$0)) + (grass_member$0 x + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0)))) + (and + (not + (grass_member$0 x + (grass_intersection$0 Alloc_Node$0 FP_Node$0))) + (not + (grass_member$0 x + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0))) + (not + (grass_member$0 x + (grass_union$0 + (grass_intersection$0 Alloc_Node$0 FP_Node$0) + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0)))))))) +(assert + (forall ((x (Loc Node))) + (or + (and (grass_member$0 x (grass_union$0 sk_?X$0 sk_?X_1$0)) + (or (grass_member$0 x sk_?X$0) + (grass_member$0 x sk_?X_1$0))) + (and (not (grass_member$0 x sk_?X$0)) + (not (grass_member$0 x sk_?X_1$0)) + (not + (grass_member$0 x (grass_union$0 sk_?X$0 sk_?X_1$0))))))) +(assert + (forall ((x (Loc Node))) + (or + (and + (grass_member$0 x + (grass_union$0 FP_Caller_Node_1$0 FP_Node$0)) + (or (grass_member$0 x FP_Caller_Node_1$0) + (grass_member$0 x FP_Node$0))) + (and (not (grass_member$0 x FP_Caller_Node_1$0)) + (not (grass_member$0 x FP_Node$0)) + (not + (grass_member$0 x + (grass_union$0 FP_Caller_Node_1$0 FP_Node$0))))))) +(assert + (forall ((x (Loc Node))) + (or + (and + (grass_member$0 x + (grass_union$0 FP_Node$0 FP_Caller_Node$0)) + (or (grass_member$0 x FP_Node$0) + (grass_member$0 x FP_Caller_Node$0))) + (and (not (grass_member$0 x FP_Node$0)) + (not (grass_member$0 x FP_Caller_Node$0)) + (not + (grass_member$0 x + (grass_union$0 FP_Node$0 FP_Caller_Node$0))))))) +(assert + (forall ((x (Loc Node))) + (or + (and + (grass_member$0 x + (grass_union$0 FP_Caller_Node$0 Alloc_Node$0)) + (or (grass_member$0 x FP_Caller_Node$0) + (grass_member$0 x Alloc_Node$0))) + (and (not (grass_member$0 x FP_Caller_Node$0)) + (not (grass_member$0 x Alloc_Node$0)) + (not + (grass_member$0 x + (grass_union$0 FP_Caller_Node$0 Alloc_Node$0))))))) +(assert + (or (grass_Btwn$0 next$0 lst$0 lst$0 lst$0) + (not (lseg$0 next$0 lst$0 lst$0 sk_?X$0)))) +(assert + (forall + ((next (Map (Loc Node) (Loc Node))) (x (Loc Node)) + (y (Loc Node)) (z (Loc Node))) + (or + (and (grass_Btwn$0 next x z y) + (grass_member$0 z (set_compr$0 next x y)) (not (= z y))) + (and (or (= z y) (not (grass_Btwn$0 next x z y))) + (not (grass_member$0 z (set_compr$0 next x y))))))) +(assert + (forall + ((?u (Loc Node)) (?x (Loc Node)) (?y (Loc Node)) + (?z (Loc Node))) + (or (not (grass_Btwn$0 next$0 ?x ?y ?z)) + (not (grass_Btwn$0 next$0 ?x ?u ?y)) + (and (grass_Btwn$0 next$0 ?x ?u ?z) + (grass_Btwn$0 next$0 ?u ?y ?z))))) +(assert + (forall + ((?u (Loc Node)) (?x (Loc Node)) (?y (Loc Node)) + (?z (Loc Node))) + (or (not (grass_Btwn$0 next$0 ?x ?y ?z)) + (not (grass_Btwn$0 next$0 ?y ?u ?z)) + (and (grass_Btwn$0 next$0 ?x ?y ?u) + (grass_Btwn$0 next$0 ?x ?u ?z))))) +(assert + (forall ((?x (Loc Node)) (?y (Loc Node)) (?z (Loc Node))) + (or (not (grass_Btwn$0 next$0 ?x ?y ?y)) + (not (grass_Btwn$0 next$0 ?y ?z ?z)) + (grass_Btwn$0 next$0 ?x ?z ?z)))) +(assert + (forall ((?x (Loc Node)) (?y (Loc Node)) (?z (Loc Node))) + (or (not (grass_Btwn$0 next$0 ?x ?y ?z)) + (and (grass_Btwn$0 next$0 ?x ?y ?y) + (grass_Btwn$0 next$0 ?y ?z ?z))))) +(assert + (forall ((?x (Loc Node)) (?y (Loc Node)) (?z (Loc Node))) + (or (not (grass_Btwn$0 next$0 ?x ?y ?y)) + (not (grass_Btwn$0 next$0 ?x ?z ?z)) + (grass_Btwn$0 next$0 ?x ?y ?z) + (grass_Btwn$0 next$0 ?x ?z ?y)))) +(assert + (forall ((?x (Loc Node)) (?y (Loc Node))) + (or (not (grass_Btwn$0 next$0 ?x ?y ?x)) (= ?x ?y)))) +(assert + (forall ((?y (Loc Node))) + (or (not (grass_Btwn$0 next$0 res_2$0 ?y ?y)) (= res_2$0 ?y) + (grass_Btwn$0 next$0 res_2$0 (grass_read$0 next$0 res_2$0) + ?y)))) +(assert + (forall ((?y (Loc Node))) + (or (not (grass_Btwn$0 next$0 lst$0 ?y ?y)) (= lst$0 ?y) + (grass_Btwn$0 next$0 lst$0 (grass_read$0 next$0 lst$0) ?y)))) +(assert + (forall ((?y (Loc Node))) + (or (not (= (grass_read$0 next$0 res_2$0) res_2$0)) + (not (grass_Btwn$0 next$0 res_2$0 ?y ?y)) (= res_2$0 ?y)))) +(assert + (forall ((?y (Loc Node))) + (or (not (= (grass_read$0 next$0 lst$0) lst$0)) + (not (grass_Btwn$0 next$0 lst$0 ?y ?y)) (= lst$0 ?y)))) +(assert + (grass_Btwn$0 next$0 res_2$0 (grass_read$0 next$0 res_2$0) + (grass_read$0 next$0 res_2$0))) +(assert + (grass_Btwn$0 next$0 lst$0 (grass_read$0 next$0 lst$0) + (grass_read$0 next$0 lst$0))) +(assert (forall ((?x (Loc Node))) (grass_Btwn$0 next$0 ?x ?x ?x))) +(assert + (or (= sk_?X$0 (set_compr$0 next$0 lst$0 lst$0)) + (not (lseg$0 next$0 lst$0 lst$0 sk_?X$0)))) +(assert (= (grass_read$0 next$0 grass_null$0) grass_null$0)) +(assert (= FP_Caller_Node_1$0 (grass_setminus$0 FP_Caller_Node$0 FP_Node$0))) +(assert (and (= lst$0 grass_null$0) Label_3$0)) +(assert (= Alloc_Node$0 (grass_union$0 FP_Caller_Node$0 Alloc_Node$0))) +(assert + (= sk_?X_4$0 + (grass_union$0 (grass_intersection$0 Alloc_Node$0 FP_Node$0) + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0)))) +(assert (= sk_?X_3$0 (grass_union$0 sk_?X$0 sk_?X_2$0))) +(assert (= sk_?X_2$0 sk_?X_1$0)) +(assert (= sk_?X_1$0 (grass_singleton$0 elt$0))) +(assert (= (grass_read$0 next$0 elt$0) grass_null$0)) +(assert (= FP_Node$0 sk_?X_3$0)) +(assert (= FP_Caller_Node$0 (grass_union$0 FP_Node$0 FP_Caller_Node$0))) +(assert (= grass_emptyset$0 (grass_intersection$0 sk_?X$0 sk_?X_2$0))) +(assert (= grass_emptyset$0 grass_emptyset$0)) +(assert (lseg$0 next$0 lst$0 grass_null$0 sk_?X$0)) +(assert + (= FP_Caller_final_Node_2$0 + (grass_union$0 FP_Caller_Node_1$0 FP_Node$0))) +(assert (= res_2$0 elt$0)) +(assert (= (grass_union$0 FP_Caller_Node$0 Alloc_Node$0) Alloc_Node$0)) +(assert (= (grass_read$0 next$0 grass_null$0) grass_null$0)) +(assert (= (grass_read$0 next$0 grass_null$0) lst$0)) +(assert (= (grass_read$0 next$0 grass_null$0) (grass_read$0 next$0 elt$0))) +(assert + (= (grass_known$1 (lseg$0 next$0 lst$0 grass_null$0 sk_?X$0)) + (grass_known$1 (lseg$0 next$0 lst$0 lst$0 sk_?X$0)))) +(assert (= (grass_intersection$0 sk_?X$0 sk_?X_2$0) grass_emptyset$0)) +(assert + (= + (grass_union$0 (grass_intersection$0 Alloc_Node$0 FP_Node$0) + (grass_setminus$0 Alloc_Node$0 Alloc_Node$0)) + sk_?X_4$0)) +(assert (= res_2$0 elt$0)) +(assert (= (grass_union$0 FP_Node$0 FP_Caller_Node$0) FP_Caller_Node$0)) +(assert (= sk_?X_1$0 (grass_singleton$0 elt$0))) +(assert (= sk_?X_1$0 sk_?X_2$0)) +(assert + (= FP_Caller_final_Node_2$0 + (grass_union$0 FP_Caller_Node_1$0 FP_Node$0))) +(assert (= FP_Node$0 sk_?X_3$0)) +(assert (= FP_Node$0 (grass_union$0 sk_?X$0 sk_?X_2$0))) +(assert (= FP_Caller_Node_1$0 (grass_setminus$0 FP_Caller_Node$0 FP_Node$0))) +(assert (= sk_?X$0 (set_compr$0 next$0 lst$0 lst$0))) +(assert (= sk_?X$0 (set_compr$0 next$0 lst$0 grass_null$0))) +(check-sat) diff --git a/test/regress/regress1/quantifiers/intersection-example-onelane.proof-node22337.smt2 b/test/regress/regress1/quantifiers/intersection-example-onelane.proof-node22337.smt2 new file mode 100644 index 000000000..38a4ed127 --- /dev/null +++ b/test/regress/regress1/quantifiers/intersection-example-onelane.proof-node22337.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --cbqi-bv +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun xI () (_ BitVec 32)) +(declare-fun A () (_ BitVec 32)) +(declare-fun B () (_ BitVec 32)) +(declare-fun vuscore2dollarskuscore80 () (_ BitVec 32)) +(declare-fun I1 () (_ BitVec 32)) +(declare-fun xuscore2dollarskuscore74 () (_ BitVec 32)) +(declare-fun v () (_ BitVec 32)) +(declare-fun ts49uscore0 () (_ BitVec 32)) +(declare-fun V () (_ BitVec 32)) +(declare-fun t87uscore0dollarskuscore0 () (_ BitVec 32)) +(declare-fun ep () (_ BitVec 32)) +(declare-fun I1uscore2dollarskuscore74 () (_ BitVec 32)) +(declare-fun x () (_ BitVec 32)) +(assert (not (exists ((ts49uscore0 (_ BitVec 32))) (let ((?v_0 (bvsge vuscore2dollarskuscore80 (_ bv0 32))) (?v_1 (bvsle vuscore2dollarskuscore80 V)) (?v_3 (bvsdiv (bvmul vuscore2dollarskuscore80 vuscore2dollarskuscore80) (bvmul (_ bv2 32) B))) (?v_2 (bvmul (bvsdiv (_ bv1 32) (_ bv2 32)) (bvadd (bvmul (bvmul (_ bv2 32) t87uscore0dollarskuscore0) vuscore2dollarskuscore80) (bvmul (_ bv2 32) xuscore2dollarskuscore74))))) (=> (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= I1uscore2dollarskuscore74 (_ bv2 32)) (=> (and (bvsle (_ bv0 32) ts49uscore0) (bvsle ts49uscore0 t87uscore0dollarskuscore0)) (and (and ?v_0 ?v_1) (bvsle ts49uscore0 ep)))) (bvsge t87uscore0dollarskuscore0 (_ bv0 32))) (= vuscore2dollarskuscore80 (_ bv0 32))) ?v_0) ?v_1) (bvsgt xI (bvadd xuscore2dollarskuscore74 ?v_3))) (= I1 (_ bv2 32))) (bvslt xI x)) (bvsgt B (_ bv0 32))) (bvsge v (_ bv0 32))) (bvsle v V)) (bvsge A (_ bv0 32))) (bvsgt V (_ bv0 32))) (bvsgt ep (_ bv0 32))) (or (or (= xI xuscore2dollarskuscore74) (bvslt xI ?v_2)) (bvsgt xI (bvadd ?v_2 ?v_3)))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/is-even.smt2 b/test/regress/regress1/quantifiers/is-even.smt2 new file mode 100644 index 000000000..9aaac5e09 --- /dev/null +++ b/test/regress/regress1/quantifiers/is-even.smt2 @@ -0,0 +1,7 @@ +(set-logic ALL_SUPPORTED) +(set-info :status unsat) + +(define-funs-rec ((is-even ((x Int)) Int) (is-odd ((y Int)) Int)) ((ite (= x 0) 1 (ite (= (is-odd (- x 1)) 0) 1 0)) (ite (= y 0) 0 (ite (= (is-even (- y 1)) 0) 1 0)))) + +(assert (= (is-even 4) 0)) +(check-sat) diff --git a/test/regress/regress1/quantifiers/javafe.ast.StmtVec.009.smt2 b/test/regress/regress1/quantifiers/javafe.ast.StmtVec.009.smt2 new file mode 100644 index 000000000..1c3aa1d8b --- /dev/null +++ b/test/regress/regress1/quantifiers/javafe.ast.StmtVec.009.smt2 @@ -0,0 +1,398 @@ +(set-logic AUFLIA) +(set-info :source | + Simplify front end test suite. + This benchmark was translated by Michal Moskal. +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun after_133.8_133.8 () Int) +(declare-fun integralOr (Int Int) Int) +(declare-fun els_81.27 () Int) +(declare-fun arrayShapeMore (Int Int) Int) +(declare-fun count_150.3 () Int) +(declare-fun tmp0_cor_166.15 () Int) +(declare-fun tmp1_elements_179.1 () Int) +(declare-fun integralAnd (Int Int) Int) +(declare-fun T_.TYPE () Int) +(declare-fun EC_167.11_167.11 () Int) +(declare-fun EC_178.11_178.11 () Int) +(declare-fun elements_83.6 () Int) +(declare-fun currentStackBottom_pre_19.87.33 () Int) +(declare-fun index_164.36 () Int) +(declare-fun intFirst () Int) +(declare-fun after_113.8_113.8 () Int) +(declare-fun elementType_pre_19.43.27 () Int) +(declare-fun eClosedTime (Int) Int) +(declare-fun int_m9223372036854775808 () Int) +(declare-fun RES_167.11_167.11 () Int) +(declare-fun RES_121.14_121.14 () Int) +(declare-fun int_m2147483648 () Int) +(declare-fun T_java.lang.Comparable () Int) +(declare-fun EC_81.32_81.32 () Int) +(declare-fun arrayPosition (Int) Int) +(declare-fun after_81.32_81.32 () Int) +(declare-fun RES_91.29_91.29 () Int) +(declare-fun EC_169.20_169.20 () Int) +(declare-fun after_151.3_151.3_19.296.17 () Int) +(declare-fun select1 (Int Int) Int) +(declare-fun select2 (Int Int Int) Int) +(declare-fun T_java.util.EscjavaKeyValue () Int) +(declare-fun cnt_91.24 () Int) +(declare-fun elems_1_ () Int) +(declare-fun owner_84.18 () Int) +(declare-fun T_long () Int) +(declare-fun T_javafe.util.StackVector () Int) +(declare-fun count_123.8 () Int) +(declare-fun lockLE (Int Int) Bool) +(declare-fun classLiteral (Int) Int) +(declare-fun after_86.8_86.8_9.342.17 () Int) +(declare-fun elements_61.33 () Int) +(declare-fun count_82.6 () Int) +(declare-fun T_java.lang.RuntimeException () Int) +(declare-fun RES_147.12_147.12 () Int) +(declare-fun lockLT (Int Int) Bool) +(declare-fun elems_2_ () Int) +(declare-fun RES_107.8_107.8 () Int) +(declare-fun elements_zero () Int) +(declare-fun T_float () Int) +(declare-fun elements_19.72.21 () Int) +(declare-fun alloc () Int) +(declare-fun RES_122.18_122.18 () Int) +(declare-fun asChild (Int Int) Int) +(declare-fun CONCVARSYM (Int) Int) +(declare-fun T_int () Int) +(declare-fun int_2147483647 () Int) +(declare-fun elementCount_pre_19.79.33 () Int) +(declare-fun int_9223372036854775807 () Int) +(declare-fun this () Int) +(declare-fun T_byte () Int) +(declare-fun T_java.lang.System () Int) +(declare-fun store1 (Int Int Int) Int) +(declare-fun store2 (Int Int Int Int) Int) +(declare-fun RES_148.13_148.13 () Int) +(declare-fun elementType_12.65.27 () Int) +(declare-fun owner_pre_4.35.28 () Int) +(declare-fun containsNull_12.70.29 () Int) +(declare-fun elements_pre_19.72.21 () Int) +(declare-fun max (Int) Int) +(declare-fun currentStackBottom_19.87.33 () Int) +(declare-fun T_java.util.List () Int) +(declare-fun objectToBeConstructed () Int) +(declare-fun T_java.util.Map () Int) +(declare-fun elementData_10.79.35 () Int) +(declare-fun EC_91.29_91.29 () Int) +(declare-fun integralDiv (Int Int) Int) +(declare-fun after_151.3_151.3_19.298.17 () Int) +(declare-fun T_java.util.AbstractCollection () Int) +(declare-fun elems_86.8_9.342.17 () Int) +(declare-fun T_java.lang.Class () Int) +(declare-fun obj_169.20_169.20_23.30.38 () Int) +(declare-fun after_151.3_151.3_19.298.31 () Int) +(declare-fun vectorCount_19.97.33 () Int) +(declare-fun T_java.lang.Object () Int) +(declare-fun tmp1_elements_84.9 () Int) +(declare-fun tmp1_cond_92.36 () Int) +(declare-fun RES_178.11_178.11 () Int) +(declare-fun tmp3_elements_86.25 () Int) +(declare-fun longLast () Int) +(declare-fun termConditional (Int Int Int) Int) +(declare-fun vectorCount_151.3_19.296.17 () Int) +(declare-fun elements_92.6 () Int) +(declare-fun T_java.util.Dictionary () Int) +(declare-fun vec_120.38 () Int) +(declare-fun elements_pre_61.33 () Int) +(declare-fun bool_false () Int) +(declare-fun Smt.true () Int) +(declare-fun EC_149.3_149.3 () Int) +(declare-fun asLockSet (Int) Int) +(declare-fun integralMod (Int Int) Int) +(declare-fun count_67.33_1_ () Int) +(declare-fun Smt.false () Int) +(declare-fun typeof (Int) Int) +(declare-fun int_18446744073709551615 () Int) +(declare-fun owner_4.35.28 () Int) +(declare-fun count_112.35 () Int) +(declare-fun elementCount_pre_10.90.35 () Int) +(declare-fun x_175.40 () Int) +(declare-fun stringCat (Int Int) Int) +(declare-fun T_java.util.Vector () Int) +(declare-fun tmp0_cor_177.5 () Int) +(declare-fun T_boolean () Int) +(declare-fun longFirst () Int) +(declare-fun T_java.util.Hashtable () Int) +(declare-fun T_java.util.Properties () Int) +(declare-fun after_91.29_91.29 () Int) +(declare-fun arrayFresh (Int Int Int Int Int Int Int) Bool) +(declare-fun tmp0_new_Stmt___92.17 () Int) +(declare-fun RES () Int) +(declare-fun EC_86.8_86.8 () Int) +(declare-fun count_95.6 () Int) +(declare-fun EC_107.8_107.8 () Int) +(declare-fun elementCount_19.79.33 () Int) +(declare-fun after_107.8_107.8 () Int) +(declare-fun intLast () Int) +(declare-fun arrayType () Int) +(declare-fun boolEq (Int Int) Bool) +(declare-fun arrayLength (Int) Int) +(declare-fun cast (Int Int) Int) +(declare-fun tmp0_cor_166.5 () Int) +(declare-fun asElems (Int) Int) +(declare-fun s_145.71 () Int) +(declare-fun T_char () Int) +(declare-fun RES_133.8_133.8 () Int) +(declare-fun owner_93.18 () Int) +(declare-fun dst_149.3_149.3_19.228.40 () Int) +(declare-fun count_pre_67.33 () Int) +(declare-fun elementType_pre_12.65.27 () Int) +(declare-fun T_javafe.ast.ASTNode () Int) +(declare-fun ecThrow () Int) +(declare-fun elementCount_151.3_19.298.17 () Int) +(declare-fun divides (Int Int) Int) +(declare-fun RES_113.8_113.8 () Int) +(declare-fun length_86.8_86.8_9.360.44 () Int) +(declare-fun anArray_124.5_124.5_10.188.45 () Int) +(declare-fun elementType_19.43.27 () Int) +(declare-fun T_javafe.util.Assert () Int) +(declare-fun InRange (Int Int) Bool) +(declare-fun count_67.33 () Int) +(declare-fun RES_81.32_81.32 () Int) +(declare-fun tmp0_cor_177.15 () Int) +(declare-fun elems_149.3_19.225.17 () Int) +(declare-fun tmp2_elements_93.9 () Int) +(declare-fun elementData_pre_10.79.35 () Int) +(declare-fun refEQ (Int Int) Int) +(declare-fun after_149.3_149.3_19.225.17 () Int) +(declare-fun is (Int Int) Int) +(declare-fun index_175.48 () Int) +(declare-fun vectorCount_pre_19.97.33 () Int) +(declare-fun integralEQ (Int Int) Int) +(declare-fun T_java.lang.ArrayIndexOutOfBoundsException () Int) +(declare-fun containsNull_pre_12.70.29 () Int) +(declare-fun boolNE (Int Int) Bool) +(declare-fun isNewArray (Int) Int) +(declare-fun elems_pre () Int) +(declare-fun T_javafe.ast.Stmt () Int) +(declare-fun intShiftL (Int Int) Int) +(declare-fun nonnullelements (Int Int) Bool) +(declare-fun T_java.util.AbstractList () Int) +(declare-fun elementCount_10.90.35 () Int) +(declare-fun multiply (Int Int) Int) +(declare-fun integralGE (Int Int) Int) +(declare-fun T_short () Int) +(declare-fun EC_151.3_151.3 () Int) +(declare-fun alloc_pre () Int) +(declare-fun integralGT (Int Int) Int) +(declare-fun EC () Int) +(declare-fun elements_61.33_1_ () Int) +(declare-fun EC_121.14_121.14 () Int) +(declare-fun boolAnd (Int Int) Bool) +(declare-fun EC_113.8_113.8 () Int) +(declare-fun T_java.util.Collection () Int) +(declare-fun arrayShapeOne (Int) Int) +(declare-fun T_double () Int) +(declare-fun longShiftL (Int Int) Int) +(declare-fun T_java.io.Serializable () Int) +(declare-fun boolOr (Int Int) Bool) +(declare-fun int_4294967295 () Int) +(declare-fun modulo (Int Int) Int) +(declare-fun EC_124.5_124.5 () Int) +(declare-fun T_java.lang.StringBuffer () Int) +(declare-fun after_122.18_122.18 () Int) +(declare-fun EC_147.12_147.12 () Int) +(declare-fun null () Int) +(declare-fun T_java.lang.Exception () Int) +(declare-fun T_java.lang.Throwable () Int) +(declare-fun currentStackBottom_151.3_19.298.31 () Int) +(declare-fun T_java.lang.String () Int) +(declare-fun EC_122.18_122.18 () Int) +(declare-fun asField (Int Int) Int) +(declare-fun after_148.13_148.13 () Int) +(declare-fun T_javafe.ast.StmtVec () Int) +(declare-fun T_java.lang.IndexOutOfBoundsException () Int) +(declare-fun boolImplies (Int Int) Bool) +(declare-fun integralLE (Int Int) Int) +(declare-fun RES_1_ () Int) +(declare-fun integralLT (Int Int) Int) +(declare-fun vAllocTime (Int) Int) +(declare-fun EC_148.13_148.13 () Int) +(declare-fun T_java.lang.Cloneable () Int) +(declare-fun boolNot (Int) Bool) +(declare-fun refNE (Int Int) Int) +(declare-fun integralXor (Int Int) Int) +(declare-fun classDown (Int Int) Int) +(declare-fun els_132.38 () Int) +(declare-fun integralNE (Int Int) Int) +(declare-fun arrayParent (Int) Int) +(declare-fun elemtype (Int) Int) +(declare-fun fClosedTime (Int) Int) +(declare-fun alloc_1_ () Int) +(declare-fun array (Int) Int) +(declare-fun LS () Int) +(declare-fun ecReturn () Int) +(declare-fun isAllocated (Int Int) Bool) +(declare-fun after_167.11_167.11 () Int) +(declare-fun after_178.11_178.11 () Int) +(declare-fun elems () Int) +(declare-fun subtypes (Int Int) Bool) +(declare-fun tmp0_new_Stmt___83.17 () Int) +(declare-fun EC_133.8_133.8 () Int) +(assert (subtypes T_java.lang.Exception T_java.lang.Throwable)) +(assert (= T_java.lang.Exception (asChild T_java.lang.Exception T_java.lang.Throwable))) +(assert (subtypes T_javafe.ast.Stmt T_javafe.ast.ASTNode)) +(assert (= T_javafe.ast.Stmt (asChild T_javafe.ast.Stmt T_javafe.ast.ASTNode))) +(assert (subtypes T_javafe.util.Assert T_java.lang.Object)) +(assert (= T_javafe.util.Assert (asChild T_javafe.util.Assert T_java.lang.Object))) +(assert (subtypes T_java.util.Properties T_java.util.Hashtable)) +(assert (= T_java.util.Properties (asChild T_java.util.Properties T_java.util.Hashtable))) +(assert (subtypes T_java.lang.Cloneable T_java.lang.Object)) +(assert (subtypes T_java.lang.IndexOutOfBoundsException T_java.lang.RuntimeException)) +(assert (= T_java.lang.IndexOutOfBoundsException (asChild T_java.lang.IndexOutOfBoundsException T_java.lang.RuntimeException))) +(assert (subtypes T_java.util.Dictionary T_java.lang.Object)) +(assert (= T_java.util.Dictionary (asChild T_java.util.Dictionary T_java.lang.Object))) +(assert (subtypes T_java.util.Dictionary T_java.util.EscjavaKeyValue)) +(assert (subtypes T_java.lang.ArrayIndexOutOfBoundsException T_java.lang.IndexOutOfBoundsException)) +(assert (= T_java.lang.ArrayIndexOutOfBoundsException (asChild T_java.lang.ArrayIndexOutOfBoundsException T_java.lang.IndexOutOfBoundsException))) +(assert (subtypes T_java.util.Map T_java.lang.Object)) +(assert (subtypes T_java.util.Map T_java.util.EscjavaKeyValue)) +(assert (subtypes T_java.io.Serializable T_java.lang.Object)) +(assert (subtypes T_java.lang.StringBuffer T_java.lang.Object)) +(assert (= T_java.lang.StringBuffer (asChild T_java.lang.StringBuffer T_java.lang.Object))) +(assert (forall ((?t Int)) (! (= (subtypes ?t T_java.lang.StringBuffer) (= ?t T_java.lang.StringBuffer)) :pattern ((subtypes ?t T_java.lang.StringBuffer)) ))) +(assert (subtypes T_java.lang.StringBuffer T_java.io.Serializable)) +(assert (subtypes T_javafe.ast.StmtVec T_java.lang.Object)) +(assert (= T_javafe.ast.StmtVec (asChild T_javafe.ast.StmtVec T_java.lang.Object))) +(assert (subtypes T_java.util.AbstractCollection T_java.lang.Object)) +(assert (= T_java.util.AbstractCollection (asChild T_java.util.AbstractCollection T_java.lang.Object))) +(assert (subtypes T_java.util.AbstractCollection T_java.util.Collection)) +(assert (subtypes T_java.util.Vector T_java.util.AbstractList)) +(assert (= T_java.util.Vector (asChild T_java.util.Vector T_java.util.AbstractList))) +(assert (subtypes T_java.util.Vector T_java.util.List)) +(assert (subtypes T_java.util.Vector T_java.lang.Cloneable)) +(assert (subtypes T_java.util.Vector T_java.io.Serializable)) +(assert (subtypes T_java.util.Hashtable T_java.util.Dictionary)) +(assert (= T_java.util.Hashtable (asChild T_java.util.Hashtable T_java.util.Dictionary))) +(assert (subtypes T_java.util.Hashtable T_java.util.Map)) +(assert (subtypes T_java.util.Hashtable T_java.lang.Cloneable)) +(assert (subtypes T_java.util.Hashtable T_java.io.Serializable)) +(assert (subtypes T_java.lang.System T_java.lang.Object)) +(assert (= T_java.lang.System (asChild T_java.lang.System T_java.lang.Object))) +(assert (forall ((?t Int)) (! (= (subtypes ?t T_java.lang.System) (= ?t T_java.lang.System)) :pattern ((subtypes ?t T_java.lang.System)) ))) +(assert (subtypes T_javafe.util.StackVector T_java.lang.Object)) +(assert (= T_javafe.util.StackVector (asChild T_javafe.util.StackVector T_java.lang.Object))) +(assert (forall ((?t Int)) (! (= (subtypes ?t T_javafe.util.StackVector) (= ?t T_javafe.util.StackVector)) :pattern ((subtypes ?t T_javafe.util.StackVector)) ))) +(assert (subtypes T_java.lang.String T_java.lang.Object)) +(assert (= T_java.lang.String (asChild T_java.lang.String T_java.lang.Object))) +(assert (forall ((?t Int)) (! (= (subtypes ?t T_java.lang.String) (= ?t T_java.lang.String)) :pattern ((subtypes ?t T_java.lang.String)) ))) +(assert (subtypes T_java.lang.String T_java.io.Serializable)) +(assert (subtypes T_java.lang.String T_java.lang.Comparable)) +(assert (subtypes T_java.util.AbstractList T_java.util.AbstractCollection)) +(assert (= T_java.util.AbstractList (asChild T_java.util.AbstractList T_java.util.AbstractCollection))) +(assert (subtypes T_java.util.AbstractList T_java.util.List)) +(assert (subtypes T_java.util.List T_java.lang.Object)) +(assert (subtypes T_java.util.List T_java.util.Collection)) +(assert (subtypes T_java.lang.Throwable T_java.lang.Object)) +(assert (= T_java.lang.Throwable (asChild T_java.lang.Throwable T_java.lang.Object))) +(assert (subtypes T_java.lang.Throwable T_java.io.Serializable)) +(assert (subtypes T_java.util.Collection T_java.lang.Object)) +(assert (subtypes T_java.lang.RuntimeException T_java.lang.Exception)) +(assert (= T_java.lang.RuntimeException (asChild T_java.lang.RuntimeException T_java.lang.Exception))) +(assert (subtypes T_java.util.EscjavaKeyValue T_java.lang.Object)) +(assert (subtypes T_java.lang.Comparable T_java.lang.Object)) +(assert (subtypes T_javafe.ast.ASTNode T_java.lang.Object)) +(assert (= T_javafe.ast.ASTNode (asChild T_javafe.ast.ASTNode T_java.lang.Object))) +(assert (subtypes T_javafe.ast.ASTNode T_java.lang.Cloneable)) +(assert (distinct arrayType T_boolean T_char T_byte T_short T_int T_long T_float T_double T_.TYPE T_java.lang.Exception T_javafe.ast.Stmt T_javafe.util.Assert T_java.util.Properties T_java.lang.Cloneable T_java.lang.IndexOutOfBoundsException T_java.util.Dictionary T_java.lang.ArrayIndexOutOfBoundsException T_java.util.Map T_java.io.Serializable T_java.lang.StringBuffer T_javafe.ast.StmtVec T_java.util.AbstractCollection T_java.util.Vector T_java.util.Hashtable T_java.lang.System T_javafe.util.StackVector T_java.lang.String T_java.lang.Object T_java.util.AbstractList T_java.util.List T_java.lang.Throwable T_java.util.Collection T_java.lang.RuntimeException T_java.util.EscjavaKeyValue T_java.lang.Comparable T_javafe.ast.ASTNode)) +(assert (forall ((?n Int)) (! (=> (and (<= 0 ?n) (< ?n 63)) (<= 1 (longShiftL 1 ?n))) :pattern ((longShiftL 1 ?n)) ))) +(assert (forall ((?n Int)) (! (=> (and (<= 0 ?n) (< ?n 31)) (<= 1 (intShiftL 1 ?n))) :pattern ((intShiftL 1 ?n)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (and (<= 0 ?x) (<= 0 ?y)) (<= 0 (integralXor ?x ?y))) :pattern ((integralXor ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (integralDiv ?x ?y))) (=> (and (<= 0 ?x) (< 0 ?y)) (and (<= 0 ?v_0) (<= ?v_0 ?x)))) :pattern ((integralDiv ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (integralOr ?x ?y))) (=> (and (<= 0 ?x) (<= 0 ?y)) (and (<= ?x ?v_0) (<= ?y ?v_0)))) :pattern ((integralOr ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (<= 0 ?y) (<= (integralAnd ?x ?y) ?y)) :pattern ((integralAnd ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (<= 0 ?x) (<= (integralAnd ?x ?y) ?x)) :pattern ((integralAnd ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (or (<= 0 ?x) (<= 0 ?y)) (<= 0 (integralAnd ?x ?y))) :pattern ((integralAnd ?x ?y)) ))) +(assert (forall ((?t Int)) (! (let ((?v_0 (classLiteral ?t))) (and (not (= ?v_0 null)) (= Smt.true (is ?v_0 T_java.lang.Class)) (isAllocated ?v_0 alloc))) :pattern ((classLiteral ?t)) ))) +(assert (forall ((?x Int) (?e Int)) (= (nonnullelements ?x ?e) (and (not (= ?x null)) (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i (arrayLength ?x))) (not (= (select1 (select1 ?e ?x) ?i) null)))))))) +(assert (forall ((?b Int) (?x Int) (?y Int)) (! (=> (not (= ?b Smt.true)) (= (termConditional ?b ?x ?y) ?y)) :pattern ((termConditional ?b ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (termConditional Smt.true ?x ?y) ?x) :pattern ((termConditional Smt.true ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (refNE ?x ?y) Smt.true) (not (= ?x ?y))) :pattern ((refNE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (refEQ ?x ?y) Smt.true) (= ?x ?y)) :pattern ((refEQ ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralNE ?x ?y) Smt.true) (not (= ?x ?y))) :pattern ((integralNE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralLT ?x ?y) Smt.true) (< ?x ?y)) :pattern ((integralLT ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralLE ?x ?y) Smt.true) (<= ?x ?y)) :pattern ((integralLE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralGT ?x ?y) Smt.true) (> ?x ?y)) :pattern ((integralGT ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralGE ?x ?y) Smt.true) (>= ?x ?y)) :pattern ((integralGE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (stringCat ?x ?y))) (and (not (= ?v_0 null)) (subtypes (typeof ?v_0) T_java.lang.String))) :pattern ((stringCat ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralEQ ?x ?y) Smt.true) (= ?x ?y)) :pattern ((integralEQ ?x ?y)) ))) +(assert (forall ((?a Int) (?b Int)) (= (boolOr ?a ?b) (or (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?a Int)) (= (boolNot ?a) (not (= ?a Smt.true))))) +(assert (forall ((?a Int) (?b Int)) (= (boolNE ?a ?b) (not (= (= ?a Smt.true) (= ?b Smt.true)))))) +(assert (forall ((?a Int) (?b Int)) (= (boolImplies ?a ?b) (=> (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?a Int) (?b Int)) (= (boolEq ?a ?b) (= (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?a Int) (?b Int)) (= (boolAnd ?a ?b) (and (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (let ((?v_0 (multiply ?x ?y))) (= (multiply (integralDiv ?v_0 ?y) ?y) ?v_0)))) +(assert (forall ((?i Int) (?j Int)) (= (integralMod (+ ?j ?i) ?j) (integralMod ?i ?j)))) +(assert (forall ((?i Int) (?j Int)) (= (integralMod (+ ?i ?j) ?j) (integralMod ?i ?j)))) +(assert (forall ((?i Int) (?j Int)) (! (let ((?v_0 (integralMod ?i ?j))) (=> (< ?j 0) (and (< ?j ?v_0) (<= ?v_0 0)))) :pattern ((integralMod ?i ?j)) ))) +(assert (forall ((?i Int) (?j Int)) (! (let ((?v_0 (integralMod ?i ?j))) (=> (< 0 ?j) (and (<= 0 ?v_0) (< ?v_0 ?j)))) :pattern ((integralMod ?i ?j)) ))) +(assert (forall ((?i Int) (?j Int)) (! (= (+ (multiply (integralDiv ?i ?j) ?j) (integralMod ?i ?j)) ?i) :pattern ((integralMod ?i ?j)) :pattern ((integralDiv ?i ?j)) ))) +(assert (forall ((?s Int)) (! (=> (= Smt.true (isNewArray ?s)) (subtypes (typeof ?s) arrayType)) :pattern ((isNewArray ?s)) ))) +(assert (forall ((?t Int)) (! (subtypes (array ?t) arrayType) :pattern ((array ?t)) ))) +(assert (= arrayType (asChild arrayType T_java.lang.Object))) +(assert (forall ((?a Int) (?a0 Int) (?b0 Int) (?e Int) (?n Int) (?T Int) (?v Int)) (! (= (arrayFresh ?a ?a0 ?b0 ?e (arrayShapeOne ?n) ?T ?v) (and (<= ?a0 (vAllocTime ?a)) (isAllocated ?a ?b0) (not (= ?a null)) (= (typeof ?a) ?T) (= (arrayLength ?a) ?n) (forall ((?i Int)) (! (= (select1 (select1 ?e ?a) ?i) ?v) :pattern ((select1 (select1 ?e ?a) ?i)) )))) :pattern ((arrayFresh ?a ?a0 ?b0 ?e (arrayShapeOne ?n) ?T ?v)) ))) +(assert (forall ((?a Int) (?a0 Int) (?b0 Int) (?e Int) (?n Int) (?s Int) (?T Int) (?v Int)) (! (= (arrayFresh ?a ?a0 ?b0 ?e (arrayShapeMore ?n ?s) ?T ?v) (and (<= ?a0 (vAllocTime ?a)) (isAllocated ?a ?b0) (not (= ?a null)) (= (typeof ?a) ?T) (= (arrayLength ?a) ?n) (forall ((?i Int)) (! (let ((?v_0 (select1 (select1 ?e ?a) ?i))) (and (arrayFresh ?v_0 ?a0 ?b0 ?e ?s (elemtype ?T) ?v) (= (arrayParent ?v_0) ?a) (= (arrayPosition ?v_0) ?i))) :pattern ((select1 (select1 ?e ?a) ?i)) )))) :pattern ((arrayFresh ?a ?a0 ?b0 ?e (arrayShapeMore ?n ?s) ?T ?v)) ))) +(assert (forall ((?a Int)) (! (let ((?v_0 (arrayLength ?a))) (and (<= 0 ?v_0) (= Smt.true (is ?v_0 T_int)))) :pattern ((arrayLength ?a)) ))) +(assert (forall ((?x Int)) (! (=> (subtypes (typeof ?x) T_java.lang.Object) (lockLE null ?x)) :pattern ((lockLE null ?x)) :pattern ((lockLT null ?x)) :pattern ((lockLE ?x null)) :pattern ((lockLT ?x null)) ))) +(assert (forall ((?S Int) (?mu Int)) (let ((?v_0 (asLockSet ?S))) (=> (= (select1 ?v_0 ?mu) Smt.true) (lockLE ?mu (max ?v_0)))))) +(assert (forall ((?x Int) (?y Int)) (= (lockLT ?x ?y) (< ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (lockLE ?x ?y) (<= ?x ?y)))) +(assert (forall ((?S Int)) (! (= (select1 (asLockSet ?S) null) Smt.true) :pattern ((asLockSet ?S)) ))) +(assert (forall ((?S Int)) (let ((?v_0 (asLockSet ?S))) (= (select1 ?v_0 (max ?v_0)) Smt.true)))) +(assert (forall ((?a Int) (?e Int) (?i Int) (?a0 Int)) (! (=> (and (< (eClosedTime ?e) ?a0) (isAllocated ?a ?a0)) (isAllocated (select1 (select1 ?e ?a) ?i) ?a0)) :pattern ((isAllocated (select1 (select1 ?e ?a) ?i) ?a0)) ))) +(assert (forall ((?x Int) (?f Int) (?a0 Int)) (! (=> (and (< (fClosedTime ?f) ?a0) (isAllocated ?x ?a0)) (isAllocated (select1 ?f ?x) ?a0)) :pattern ((isAllocated (select1 ?f ?x) ?a0)) ))) +(assert (forall ((?x Int) (?a0 Int)) (= (isAllocated ?x ?a0) (< (vAllocTime ?x) ?a0)))) +(assert (forall ((?e Int) (?a Int) (?i Int)) (! (= Smt.true (is (select1 (select1 (asElems ?e) ?a) ?i) (elemtype (typeof ?a)))) :pattern ((select1 (select1 (asElems ?e) ?a) ?i)) ))) +(assert (forall ((?f Int) (?t Int) (?x Int)) (! (= Smt.true (is (select1 (asField ?f ?t) ?x) ?t)) :pattern ((select1 (asField ?f ?t) ?x)) ))) +(assert (forall ((?x Int) (?t Int)) (! (=> (subtypes ?t T_java.lang.Object) (= (= Smt.true (is ?x ?t)) (or (= ?x null) (subtypes (typeof ?x) ?t)))) :pattern ((subtypes ?t T_java.lang.Object) (is ?x ?t)) ))) +(assert (< intLast longLast)) +(assert (< 1000000 intLast)) +(assert (< intFirst (- 1000000))) +(assert (< longFirst intFirst)) +(assert (forall ((?x Int)) (! (= (= Smt.true (is ?x T_long)) (and (<= longFirst ?x) (<= ?x longLast))) :pattern ((is ?x T_long)) ))) +(assert (forall ((?x Int)) (! (= (= Smt.true (is ?x T_int)) (and (<= intFirst ?x) (<= ?x intLast))) :pattern ((is ?x T_int)) ))) +(assert (forall ((?x Int)) (= (= Smt.true (is ?x T_short)) (and (<= (- 32768) ?x) (<= ?x 32767))))) +(assert (forall ((?x Int)) (= (= Smt.true (is ?x T_byte)) (and (<= (- 128) ?x) (<= ?x 127))))) +(assert (forall ((?x Int)) (! (= (= Smt.true (is ?x T_char)) (and (<= 0 ?x) (<= ?x 65535))) :pattern ((is ?x T_char)) ))) +(assert (distinct bool_false Smt.true)) +(assert (forall ((?x Int) (?t Int)) (! (=> (= Smt.true (is ?x ?t)) (= (cast ?x ?t) ?x)) :pattern ((cast ?x ?t)) ))) +(assert (forall ((?x Int) (?t Int)) (! (= Smt.true (is (cast ?x ?t) ?t)) :pattern ((cast ?x ?t)) ))) +(assert (forall ((?t0 Int) (?t1 Int)) (! (let ((?v_0 (elemtype ?t0))) (= (subtypes ?t0 (array ?t1)) (and (= ?t0 (array ?v_0)) (subtypes ?v_0 ?t1)))) :pattern ((subtypes ?t0 (array ?t1))) ))) +(assert (forall ((?t Int)) (! (= (elemtype (array ?t)) ?t) :pattern ((elemtype (array ?t))) ))) +(assert (forall ((?t Int)) (! (subtypes (array ?t) T_java.lang.Cloneable) :pattern ((array ?t)) ))) +(assert (subtypes T_java.lang.Cloneable T_java.lang.Object)) +(assert (forall ((?t0 Int) (?t1 Int) (?t2 Int)) (let ((?v_0 (asChild ?t1 ?t2))) (=> (subtypes ?t0 ?v_0) (= (classDown ?t2 ?t0) ?v_0))))) +(assert (forall ((?t Int)) (! (=> (subtypes T_double ?t) (= ?t T_double)) :pattern ((subtypes T_double ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_float ?t) (= ?t T_float)) :pattern ((subtypes T_float ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_long ?t) (= ?t T_long)) :pattern ((subtypes T_long ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_int ?t) (= ?t T_int)) :pattern ((subtypes T_int ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_short ?t) (= ?t T_short)) :pattern ((subtypes T_short ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_byte ?t) (= ?t T_byte)) :pattern ((subtypes T_byte ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_char ?t) (= ?t T_char)) :pattern ((subtypes T_char ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_boolean ?t) (= ?t T_boolean)) :pattern ((subtypes T_boolean ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_double) (= ?t T_double)) :pattern ((subtypes ?t T_double)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_float) (= ?t T_float)) :pattern ((subtypes ?t T_float)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_long) (= ?t T_long)) :pattern ((subtypes ?t T_long)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_int) (= ?t T_int)) :pattern ((subtypes ?t T_int)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_short) (= ?t T_short)) :pattern ((subtypes ?t T_short)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_byte) (= ?t T_byte)) :pattern ((subtypes ?t T_byte)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_char) (= ?t T_char)) :pattern ((subtypes ?t T_char)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_boolean) (= ?t T_boolean)) :pattern ((subtypes ?t T_boolean)) ))) +(assert (forall ((?t0 Int) (?t1 Int)) (! (=> (and (subtypes ?t0 ?t1) (subtypes ?t1 ?t0)) (= ?t0 ?t1)) :pattern ((subtypes ?t0 ?t1) (subtypes ?t1 ?t0)) ))) +(assert (forall ((?t0 Int) (?t1 Int) (?t2 Int)) (! (=> (and (subtypes ?t0 ?t1) (subtypes ?t1 ?t2)) (subtypes ?t0 ?t2)) :pattern ((subtypes ?t0 ?t1) (subtypes ?t1 ?t2)) ))) +(assert (subtypes T_java.lang.Object T_java.lang.Object)) +(assert (forall ((?t Int)) (! (subtypes ?t ?t) :pattern ((subtypes ?t ?t)) ))) +(assert (forall ((?m Int) (?i Int) (?j Int) (?x Int)) (=> (not (= ?i ?j)) (= (select1 (store1 ?m ?i ?x) ?j) (select1 ?m ?j))))) +(assert (forall ((?m Int) (?i Int) (?x Int)) (= (select1 (store1 ?m ?i ?x) ?i) ?x))) +(assert (let ((?v_0 (array T_java.lang.Object)) (?v_6 (<= 0 index_175.48)) (?v_2 (select1 count_67.33 this)) (?v_1 (< index_175.48 0)) (?v_3 (= Smt.true Smt.true))) (let ((?v_8 (or (and ?v_1 ?v_3 (= tmp0_cor_177.15 Smt.true)) (and (not ?v_1) (= tmp0_cor_177.5 (integralGE index_175.48 ?v_2)) (= tmp0_cor_177.15 tmp0_cor_177.5)))) (?v_5 (= Smt.true tmp0_cor_177.15)) (?v_12 (< alloc after_178.11_178.11)) (?v_4 (not (= RES_178.11_178.11 null))) (?v_13 (not (isAllocated RES_178.11_178.11 alloc))) (?v_14 (= Smt.true (is RES_178.11_178.11 T_java.lang.ArrayIndexOutOfBoundsException))) (?v_15 (isAllocated RES_178.11_178.11 after_178.11_178.11)) (?v_16 (= EC_178.11_178.11 ecReturn)) (?v_17 (= (select1 owner_4.35.28 RES_178.11_178.11) null)) (?v_18 (= (typeof RES_178.11_178.11) T_java.lang.ArrayIndexOutOfBoundsException))) (let ((?v_9 (not ?v_5)) (?v_10 (= tmp1_elements_179.1 (select1 elements_61.33 this))) (?v_7 (< index_175.48 (arrayLength tmp1_elements_179.1))) (?v_11 (= Smt.true (is x_175.40 (elemtype (typeof tmp1_elements_179.1))))) (?v_19 (= EC ecReturn))) (not (=> (distinct ecReturn ecThrow) (=> (and (= elementCount_pre_19.79.33 elementCount_19.79.33) (= elementCount_19.79.33 (asField elementCount_19.79.33 T_int)) (= elementData_pre_10.79.35 elementData_10.79.35) (= elementData_10.79.35 (asField elementData_10.79.35 ?v_0)) (< (fClosedTime elementData_10.79.35) alloc) (forall ((?s Int)) (=> (not (= ?s null)) (not (= (select1 elementData_10.79.35 ?s) null)))) (= count_pre_67.33 count_67.33) (= count_67.33 (asField count_67.33 T_int)) (= owner_pre_4.35.28 owner_4.35.28) (= owner_4.35.28 (asField owner_4.35.28 T_java.lang.Object)) (< (fClosedTime owner_4.35.28) alloc) (= elementType_pre_19.43.27 elementType_19.43.27) (= elementType_19.43.27 (asField elementType_19.43.27 T_.TYPE)) (= containsNull_pre_12.70.29 containsNull_12.70.29) (= containsNull_12.70.29 (asField containsNull_12.70.29 T_boolean)) (= elements_pre_19.72.21 elements_19.72.21) (= elements_19.72.21 (asField elements_19.72.21 ?v_0)) (< (fClosedTime elements_19.72.21) alloc) (= elements_pre_61.33 elements_61.33) (= elements_61.33 (asField elements_61.33 (array T_javafe.ast.Stmt))) (< (fClosedTime elements_61.33) alloc) (forall ((?s_1_ Int)) (=> (not (= ?s_1_ null)) (not (= (select1 elements_61.33 ?s_1_) null)))) (= elementType_pre_12.65.27 elementType_12.65.27) (= elementType_12.65.27 (asField elementType_12.65.27 T_.TYPE)) (= elementCount_pre_10.90.35 elementCount_10.90.35) (= elementCount_10.90.35 (asField elementCount_10.90.35 T_int)) (= currentStackBottom_pre_19.87.33 currentStackBottom_19.87.33) (= currentStackBottom_19.87.33 (asField currentStackBottom_19.87.33 T_int)) (= vectorCount_pre_19.97.33 vectorCount_19.97.33) (= vectorCount_19.97.33 (asField vectorCount_19.97.33 T_int)) (= elems_pre elems) (= elems (asElems elems)) (< (eClosedTime elems) alloc) (= LS (asLockSet LS)) (= alloc_pre alloc)) (not (and (= Smt.true (is this T_javafe.ast.StmtVec)) (isAllocated this alloc) (not (= this null)) (= Smt.true (is x_175.40 T_javafe.ast.Stmt)) (isAllocated x_175.40 alloc) (= Smt.true (is index_175.48 T_int)) ?v_6 (< index_175.48 ?v_2) (not (= x_175.40 null)) (forall ((?brokenObj Int)) (=> (and (= Smt.true (is ?brokenObj T_javafe.ast.StmtVec)) (not (= ?brokenObj null))) (forall ((?i_62.31 Int)) (=> (and (<= 0 ?i_62.31) (< ?i_62.31 (select1 count_67.33 ?brokenObj))) (not (= (select1 (select1 elems (select1 elements_61.33 ?brokenObj)) ?i_62.31) null)))))) (forall ((?brokenObj_1_ Int)) (=> (and (= Smt.true (is ?brokenObj_1_ T_javafe.ast.StmtVec)) (not (= ?brokenObj_1_ null))) (<= (select1 count_67.33 ?brokenObj_1_) (arrayLength (select1 elements_61.33 ?brokenObj_1_))))) (forall ((?brokenObj_2_ Int)) (=> (and (= Smt.true (is ?brokenObj_2_ T_javafe.ast.StmtVec)) (not (= ?brokenObj_2_ null))) (<= 0 (select1 count_67.33 ?brokenObj_2_)))) (forall ((?brokenObj_3_ Int)) (=> (and (= Smt.true (is ?brokenObj_3_ T_javafe.ast.StmtVec)) (not (= ?brokenObj_3_ null))) (= (select1 owner_4.35.28 (select1 elements_61.33 ?brokenObj_3_)) ?brokenObj_3_))) (forall ((?brokenObj_4_ Int)) (=> (and (= Smt.true (is ?brokenObj_4_ T_javafe.ast.StmtVec)) (not (= ?brokenObj_4_ null))) (= (typeof (select1 elements_61.33 ?brokenObj_4_)) (array T_javafe.ast.Stmt)))) (or (and ?v_8 (or (and ?v_5 ?v_3 ?v_12 ?v_4 ?v_13 ?v_14 ?v_15 ?v_16 ?v_17 ?v_18 (not ?v_4)) (and ?v_9 ?v_3 ?v_10 (or (not ?v_6) (and ?v_6 (or (not ?v_7) (and ?v_7 (not ?v_11)))))))) (and (or (and ?v_8 ?v_9 ?v_3 ?v_10 ?v_6 ?v_7 ?v_11 (= elems_1_ (store1 elems tmp1_elements_179.1 (store1 (select1 elems tmp1_elements_179.1) index_175.48 x_175.40))) (= elems_2_ elems_1_) ?v_19 (= alloc_1_ alloc)) (and ?v_8 ?v_5 ?v_3 ?v_12 ?v_4 ?v_13 ?v_14 ?v_15 ?v_16 ?v_17 ?v_18 ?v_4 ?v_3 (= elems_2_ elems) (= EC ecThrow) (= alloc_1_ after_178.11_178.11))) (or (not ?v_19) (and ?v_19 (not (forall ((?brokenObj Int)) (=> (and (= Smt.true (is ?brokenObj T_javafe.ast.StmtVec)) (isAllocated ?brokenObj alloc_1_) (not (= ?brokenObj null))) (forall ((?i_62.31 Int)) (=> (and (<= 0 ?i_62.31) (< ?i_62.31 (select1 count_67.33 ?brokenObj))) (not (= (select1 (select1 elems_2_ (select1 elements_61.33 ?brokenObj)) ?i_62.31) null)))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/macro-subtype-param.smt2 b/test/regress/regress1/quantifiers/macro-subtype-param.smt2 new file mode 100644 index 000000000..97ff827a7 --- /dev/null +++ b/test/regress/regress1/quantifiers/macro-subtype-param.smt2 @@ -0,0 +1,23 @@ +; COMMAND-LINE: --macros-quant +; EXPECT: (error "argument type is not a subtype of the function's argument type: +; EXPECT: argument: x +; EXPECT: has type: (List Int) +; EXPECT: not subtype: (List Real) +; EXPECT: in term : (R (as x (List Real)))") +; EXIT: 1 + +(set-logic ALL_SUPPORTED) + +(declare-datatypes ((List 1)) ((par (T) ((cons (hd T) (tl (List T))) (nil))))) + +(declare-fun R ((List Real)) Bool) +(assert (forall ((x (List Int))) (R x))) +(declare-fun j1 () (List Real)) +(assert (not (R j1))) + +(declare-fun Q ((Array Int Real)) Bool) +(assert (forall ((x (Array Real Int))) (Q x))) +(declare-fun j2 () (Array Real Real)) +(assert (not (Q j2))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/mix-coeff.smt2 b/test/regress/regress1/quantifiers/mix-coeff.smt2 new file mode 100644 index 000000000..23ecba49e --- /dev/null +++ b/test/regress/regress1/quantifiers/mix-coeff.smt2 @@ -0,0 +1,4 @@ +(set-logic LIRA) +(set-info :status unsat) +(assert (forall ((x Int) (y Int) (a Real) (z Int)) (or (> x (+ a (* (/ 2 3) y) (* (/ 4 5) z))) (< x (+ 10 (* 3 a) (* (/ 2 5) y) (* (/ 4 7) z)))))) +(check-sat) diff --git a/test/regress/regress1/quantifiers/model_6_1_bv.smt2 b/test/regress/regress1/quantifiers/model_6_1_bv.smt2 new file mode 100644 index 000000000..011430bd6 --- /dev/null +++ b/test/regress/regress1/quantifiers/model_6_1_bv.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --cbqi-nested-qe +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun lambda () (_ BitVec 32)) +(declare-fun lambdaprime () (_ BitVec 32)) +(declare-fun x5 () (_ BitVec 32)) +(declare-fun x4 () (_ BitVec 32)) +(declare-fun bool.b22 () Bool) +(declare-fun bool.b7 () Bool) +(declare-fun bool.b5 () Bool) +(declare-fun bool.b6 () Bool) +(assert (forall ((?lambda (_ BitVec 32))) (or (or (exists ((?lambdaprime (_ BitVec 32))) (let ((?v_1 (not bool.b22)) (?v_3 (not bool.b7)) (?v_4 (not bool.b5))) (let ((?v_2 (and ?v_4 (not bool.b6))) (?v_0 (bvmul (bvneg (_ bv1 32)) (bvadd x4 (bvmul (_ bv30 32) ?lambdaprime))))) (and (and (bvsle (_ bv0 32) ?lambdaprime) (bvsle ?lambdaprime ?lambda)) (not (and (not (bvsle (bvmul (bvneg (_ bv1 32)) (bvadd x5 (bvmul (_ bv1 32) ?lambdaprime))) (bvneg (_ bv10 32)))) (and (and (not (and (bvsle ?v_0 (bvneg (_ bv4100 32))) (and ?v_1 (and ?v_3 ?v_2)))) (not (and (bvsle ?v_0 (bvneg (_ bv4500 32))) (and ?v_1 (and bool.b7 ?v_2))))) (not (and (bvsle ?v_0 (bvneg (_ bv4910 32))) (and ?v_1 (and ?v_3 (and ?v_4 bool.b6)))))))))))) (bvslt ?lambda (_ bv0 32))) (not (and (not bool.b22) (and (not bool.b7) (and bool.b5 (not bool.b6)))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/nested9_true-unreach-call.i_575.smt2 b/test/regress/regress1/quantifiers/nested9_true-unreach-call.i_575.smt2 new file mode 100644 index 000000000..2a46d2a21 --- /dev/null +++ b/test/regress/regress1/quantifiers/nested9_true-unreach-call.i_575.smt2 @@ -0,0 +1,21 @@ +; COMMAND-LINE: --cbqi-bv +; EXPECT: unsat +(set-logic BV) +(set-info :status unsat) +(declare-fun c_main_~i~6 () (_ BitVec 32)) +(declare-fun c_main_~j~6 () (_ BitVec 32)) +(declare-fun c_main_~k~6 () (_ BitVec 32)) +(assert + (and (bvsle c_main_~i~6 (_ bv3 32)) (bvsle c_main_~i~6 (_ bv2 32)) + (exists ((v_nnf_34 (_ BitVec 32))) + (and (bvsle (bvadd v_nnf_34 (_ bv3 32)) c_main_~k~6) + (bvsle v_nnf_34 (_ bv3 32)) (bvsle c_main_~j~6 (bvadd (bvmul (_ bv2 32) v_nnf_34) (_ bv1 32))))))) +(assert + (not + (and (bvsle c_main_~i~6 (_ bv3 32)) (bvsle c_main_~i~6 (_ bv2 32)) + (exists ((v_nnf_30 (_ BitVec 32))) + (and (bvsle (bvadd v_nnf_30 (_ bv1 32)) c_main_~k~6) + (bvsle v_nnf_30 (_ bv3 32)) (bvsle c_main_~j~6 (bvadd (bvmul (_ bv2 32) v_nnf_30) (_ bv1 32)))))))) +(check-sat) +(exit) + diff --git a/test/regress/regress1/quantifiers/opisavailable-12.smt2 b/test/regress/regress1/quantifiers/opisavailable-12.smt2 new file mode 100644 index 000000000..c529b409f --- /dev/null +++ b/test/regress/regress1/quantifiers/opisavailable-12.smt2 @@ -0,0 +1,276 @@ +(set-logic AUFLIA) +(set-info :source | + Tokeneer case study <http://www.adacore.com/home/products/gnatpro/tokeneer/> + |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun field.datat.length () Int) +(declare-fun field.datat.minmatchlength () Int) +(declare-fun field.datat.text () Int) +(declare-fun field.keyboard__datat.length () Int) +(declare-fun field.keyboard__datat.text () Int) +(declare-fun field.t.rolepresent () Int) +(declare-fun field.t.currentop () Int) +(declare-fun archivelog () Int) +(declare-fun character__base__first () Int) +(declare-fun character__base__last () Int) +(declare-fun character__first () Int) +(declare-fun character__last () Int) +(declare-fun character__size () Int) +(declare-fun datai__base__first () Int) +(declare-fun datai__base__last () Int) +(declare-fun datai__first () Int) +(declare-fun datai__last () Int) +(declare-fun datai__size () Int) +(declare-fun datalengtht__base__first () Int) +(declare-fun datalengtht__base__last () Int) +(declare-fun datalengtht__first () Int) +(declare-fun datalengtht__last () Int) +(declare-fun datalengtht__size () Int) +(declare-fun integer__base__first () Int) +(declare-fun integer__base__last () Int) +(declare-fun integer__first () Int) +(declare-fun integer__last () Int) +(declare-fun integer__size () Int) +(declare-fun isavailable () Int) +(declare-fun keyboard__datai__base__first () Int) +(declare-fun keyboard__datai__base__last () Int) +(declare-fun keyboard__datai__first () Int) +(declare-fun keyboard__datai__last () Int) +(declare-fun keyboard__datai__size () Int) +(declare-fun keyboard__datalengtht__base__first () Int) +(declare-fun keyboard__datalengtht__base__last () Int) +(declare-fun keyboard__datalengtht__first () Int) +(declare-fun keyboard__datalengtht__last () Int) +(declare-fun keyboard__datalengtht__size () Int) +(declare-fun null__string () Int) +(declare-fun nullop () Int) +(declare-fun opandnullt__base__first () Int) +(declare-fun opandnullt__base__last () Int) +(declare-fun opandnullt__first () Int) +(declare-fun opandnullt__last () Int) +(declare-fun opandnullt__size () Int) +(declare-fun opt__base__first () Int) +(declare-fun opt__base__last () Int) +(declare-fun opt__first () Int) +(declare-fun opt__last () Int) +(declare-fun opt__size () Int) +(declare-fun optokeyed () Int) +(declare-fun overridelock () Int) +(declare-fun positive__base__first () Int) +(declare-fun positive__base__last () Int) +(declare-fun positive__first () Int) +(declare-fun positive__last () Int) +(declare-fun positive__size () Int) +(declare-fun privtypes__adminprivileget__base__first () Int) +(declare-fun privtypes__adminprivileget__base__last () Int) +(declare-fun privtypes__adminprivileget__first () Int) +(declare-fun privtypes__adminprivileget__last () Int) +(declare-fun privtypes__adminprivileget__size () Int) +(declare-fun privtypes__auditmanager () Int) +(declare-fun privtypes__guard () Int) +(declare-fun privtypes__privileget__base__first () Int) +(declare-fun privtypes__privileget__base__last () Int) +(declare-fun privtypes__privileget__first () Int) +(declare-fun privtypes__privileget__last () Int) +(declare-fun privtypes__privileget__size () Int) +(declare-fun privtypes__securityofficer () Int) +(declare-fun privtypes__useronly () Int) +(declare-fun shutdownop () Int) +(declare-fun updateconfigdata () Int) +(declare-fun keyedop () Int) +(declare-fun keyedop__entry__loop__2 () Int) +(declare-fun init.keyedop__entry__loop__2 () Int) +(declare-fun init.keyedop () Int) +(declare-fun loop__1__op () Int) +(declare-fun init.loop__1__op () Int) +(declare-fun loop__2__i () Int) +(declare-fun init.loop__2__i () Int) +(declare-fun theadmin () Int) +(declare-fun init.theadmin () Int) +(declare-fun theop () Int) +(declare-fun init.theop () Int) +(declare-fun bit__and (Int Int) Int) +(declare-fun bit__not (Int Int) Int) +(declare-fun bit__or (Int Int) Int) +(declare-fun bit__xor (Int Int) Int) +(declare-fun character__pos (Int) Int) +(declare-fun character__val (Int) Int) +(declare-fun integer__pred (Int) Int) +(declare-fun integer__succ (Int) Int) +(declare-fun opandnullt__pos (Int) Int) +(declare-fun opandnullt__pred (Int) Int) +(declare-fun opandnullt__succ (Int) Int) +(declare-fun opandnullt__val (Int) Int) +(declare-fun privtypes__privileget__pos (Int) Int) +(declare-fun privtypes__privileget__pred (Int) Int) +(declare-fun privtypes__privileget__succ (Int) Int) +(declare-fun privtypes__privileget__val (Int) Int) +(declare-fun round__ (Int) Int) +(declare-fun i.div (Int Int) Int) +(declare-fun i.mod (Int Int) Int) +(declare-fun i.mult (Int Int) Int) +(declare-fun i.exp (Int Int) Int) +(declare-fun tm.true () Int) +(declare-fun tm.false () Int) +(declare-fun tm.not (Int) Int) +(declare-fun tm.and (Int Int) Int) +(declare-fun tm.or (Int Int) Int) +(declare-fun tm.iff (Int Int) Int) +(declare-fun tm.eq (Int Int) Int) +(declare-fun tm.ne (Int Int) Int) +(declare-fun tm.lt (Int Int) Int) +(declare-fun tm.le (Int Int) Int) +(declare-fun tuple.2 (Int Int) Int) +(declare-fun a.store (Int Int Int) Int) +(declare-fun a.select (Int Int) Int) +(declare-fun a.mk_const_array (Int) Int) +(declare-fun a.default_array () Int) +(declare-fun r.default_record () Int) +(declare-fun matched () Bool) +(declare-fun init.matched () Bool) +(declare-fun ispresent (Int) Bool) +(declare-fun opandnullt__LE (Int Int) Bool) +(declare-fun opandnullt__LT (Int Int) Bool) +(declare-fun privtypes__privileget__LE (Int Int) Bool) +(declare-fun privtypes__privileget__LT (Int Int) Bool) +(assert (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i 4)) (= (privtypes__privileget__pos ?i) ?i)))) +(assert (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i 4)) (= (privtypes__privileget__val ?i) ?i)))) +(assert (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i 3)) (= (privtypes__privileget__succ ?i) (+ ?i 1))))) +(assert (forall ((?i Int)) (=> (and (<= 1 ?i) (< ?i 4)) (= (privtypes__privileget__pred ?i) (- ?i 1))))) +(assert (= privtypes__useronly 0)) +(assert (= privtypes__guard 1)) +(assert (= privtypes__auditmanager 2)) +(assert (= privtypes__securityofficer 3)) +(assert (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i 5)) (= (opandnullt__pos ?i) ?i)))) +(assert (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i 5)) (= (opandnullt__val ?i) ?i)))) +(assert (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i 4)) (= (opandnullt__succ ?i) (+ ?i 1))))) +(assert (forall ((?i Int)) (=> (and (<= 1 ?i) (< ?i 5)) (= (opandnullt__pred ?i) (- ?i 1))))) +(assert (= nullop 0)) +(assert (= archivelog 1)) +(assert (= updateconfigdata 2)) +(assert (= overridelock 3)) +(assert (= shutdownop 4)) +(assert (forall ((?I Int)) (=> (and (<= archivelog ?I) (<= ?I shutdownop)) (<= datalengtht__first (a.select (a.select optokeyed ?I) field.datat.length))))) +(assert (forall ((?I Int)) (=> (and (<= archivelog ?I) (<= ?I shutdownop)) (<= (a.select (a.select optokeyed ?I) field.datat.length) datalengtht__last)))) +(assert (forall ((?I Int)) (=> (and (<= archivelog ?I) (<= ?I shutdownop)) (<= datai__first (a.select (a.select optokeyed ?I) field.datat.minmatchlength))))) +(assert (forall ((?I Int)) (=> (and (<= archivelog ?I) (<= ?I shutdownop)) (<= (a.select (a.select optokeyed ?I) field.datat.minmatchlength) datai__last)))) +(assert (forall ((?I Int) (?J Int)) (=> (and (<= archivelog ?I) (<= ?I shutdownop) (<= 1 ?J) (<= ?J 18)) (<= character__first (a.select (a.select (a.select optokeyed ?I) field.datat.text) ?J))))) +(assert (forall ((?I Int) (?J Int)) (=> (and (<= archivelog ?I) (<= ?I shutdownop) (<= 1 ?J) (<= ?J 18)) (<= (a.select (a.select (a.select optokeyed ?I) field.datat.text) ?J) character__last)))) +(assert (<= 0 integer__size)) +(assert (= integer__first (- 2147483648))) +(assert (= integer__last 2147483647)) +(assert (= integer__base__first (- 2147483648))) +(assert (= integer__base__last 2147483647)) +(assert (<= 0 character__size)) +(assert (= character__first 0)) +(assert (= character__last 255)) +(assert (= character__base__first 0)) +(assert (= character__base__last 255)) +(assert (<= 0 positive__size)) +(assert (= positive__first 1)) +(assert (= positive__last 2147483647)) +(assert (= positive__base__first (- 2147483648))) +(assert (= positive__base__last 2147483647)) +(assert (<= 0 privtypes__privileget__size)) +(assert (= privtypes__privileget__first privtypes__useronly)) +(assert (= privtypes__privileget__last privtypes__securityofficer)) +(assert (= privtypes__privileget__base__first privtypes__useronly)) +(assert (= privtypes__privileget__base__last privtypes__securityofficer)) +(assert (<= 0 privtypes__adminprivileget__size)) +(assert (= privtypes__adminprivileget__first privtypes__guard)) +(assert (= privtypes__adminprivileget__last privtypes__securityofficer)) +(assert (= privtypes__adminprivileget__base__first privtypes__useronly)) +(assert (= privtypes__adminprivileget__base__last privtypes__securityofficer)) +(assert (<= 0 keyboard__datalengtht__size)) +(assert (= keyboard__datalengtht__first 0)) +(assert (= keyboard__datalengtht__last 78)) +(assert (= keyboard__datalengtht__base__first (- 2147483648))) +(assert (= keyboard__datalengtht__base__last 2147483647)) +(assert (<= 0 keyboard__datai__size)) +(assert (= keyboard__datai__first 1)) +(assert (= keyboard__datai__last 78)) +(assert (= keyboard__datai__base__first (- 2147483648))) +(assert (= keyboard__datai__base__last 2147483647)) +(assert (<= 0 opandnullt__size)) +(assert (= opandnullt__first nullop)) +(assert (= opandnullt__last shutdownop)) +(assert (= opandnullt__base__first nullop)) +(assert (= opandnullt__base__last shutdownop)) +(assert (<= 0 opt__size)) +(assert (= opt__first archivelog)) +(assert (= opt__last shutdownop)) +(assert (= opt__base__first nullop)) +(assert (= opt__base__last shutdownop)) +(assert (<= 0 datalengtht__size)) +(assert (= datalengtht__first 0)) +(assert (= datalengtht__last 18)) +(assert (= datalengtht__base__first (- 2147483648))) +(assert (= datalengtht__base__last 2147483647)) +(assert (<= 0 datai__size)) +(assert (= datai__first 1)) +(assert (= datai__last 18)) +(assert (= datai__base__first (- 2147483648))) +(assert (= datai__base__last 2147483647)) +(assert (forall ((?X Int) (?Y Int)) (=> (< 0 ?Y) (<= 0 (i.mod ?X ?Y))))) +(assert (forall ((?X Int) (?Y Int)) (=> (< 0 ?Y) (< (i.mod ?X ?Y) ?Y)))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= 0 ?X) (< 0 ?Y)) (<= (i.mult ?Y (i.div ?X ?Y)) ?X)))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= 0 ?X) (< 0 ?Y)) (< (- ?X ?Y) (i.mult ?Y (i.div ?X ?Y)))))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= ?X 0) (< 0 ?Y)) (<= ?X (i.mult ?Y (i.div ?X ?Y)))))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= ?X 0) (< 0 ?Y)) (< (i.mult ?Y (i.div ?X ?Y)) (+ ?X ?Y))))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= 0 ?X) (<= 0 ?Y)) (<= 0 (bit__or ?X ?Y))))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= 0 ?X) (<= 0 ?Y)) (<= ?X (bit__or ?X ?Y))))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= 0 ?X) (<= 0 ?Y)) (<= ?Y (bit__or ?X ?Y))))) +(assert (forall ((?X Int) (?Y Int)) (=> (and (<= 0 ?X) (<= 0 ?Y)) (<= (bit__or ?X ?Y) (+ ?X ?Y))))) +(assert (distinct field.datat.length field.datat.minmatchlength field.datat.text)) +(assert (distinct field.keyboard__datat.length field.keyboard__datat.text)) +(assert (distinct field.t.rolepresent field.t.currentop)) +(assert (distinct tm.true tm.false)) +(assert (forall ((?x Int)) (! (= (= (tm.not ?x) tm.true) (not (= ?x tm.true))) :pattern ((tm.not ?x)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (tm.and ?x ?y) tm.true) (and (= ?x tm.true) (= ?y tm.true))) :pattern ((tm.and ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (tm.or ?x ?y) tm.true) (or (= ?x tm.true) (= ?y tm.true))) :pattern ((tm.or ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (tm.iff ?x ?y) tm.true) (= (= ?x tm.true) (= ?y tm.true))) :pattern ((tm.iff ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (tm.eq ?x ?y) tm.true) (= ?x ?y)) :pattern ((tm.eq ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (tm.ne ?x ?y) tm.true) (not (= ?x ?y))) :pattern ((tm.ne ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (tm.lt ?x ?y) tm.true) (< ?x ?y)) :pattern ((tm.lt ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (tm.le ?x ?y) tm.true) (<= ?x ?y)) :pattern ((tm.le ?x ?y)) ))) +(assert (forall ((?a Int) (?i Int) (?v Int)) (! (= (a.select (a.store ?a ?i ?v) ?i) ?v) :pattern ((a.select (a.store ?a ?i ?v) ?i)) ))) +(assert (forall ((?a Int) (?i Int) (?v Int) (?j Int)) (! (or (= ?i ?j) (= (a.select (a.store ?a ?i ?v) ?j) (a.select ?a ?j))) :pattern ((a.select (a.store ?a ?i ?v) ?j)) ))) +(assert (forall ((?i Int) (?v Int)) (! (= (a.select (a.mk_const_array ?v) ?i) ?v) :pattern ((a.select (a.mk_const_array ?v) ?i)) ))) +(assert (<= opt__first loop__1__op)) +(assert (<= loop__1__op opt__last)) +(assert (<= datai__first loop__2__i)) +(assert (<= loop__2__i datai__last)) +(assert (<= loop__2__i (a.select keyedop field.keyboard__datat.length))) +(assert (<= datai__first (a.select keyedop field.keyboard__datat.length))) +(assert (<= (a.select keyedop field.keyboard__datat.length) datai__last)) +(assert (= keyedop keyedop__entry__loop__2)) +(assert (<= privtypes__adminprivileget__first (a.select theadmin field.t.rolepresent))) +(assert (<= (a.select theadmin field.t.rolepresent) privtypes__adminprivileget__last)) +(assert (= theop nullop)) +(assert (<= opandnullt__first (a.select theadmin field.t.currentop))) +(assert (<= (a.select theadmin field.t.currentop) opandnullt__last)) +(assert (<= privtypes__privileget__first (a.select theadmin field.t.rolepresent))) +(assert (<= (a.select theadmin field.t.rolepresent) privtypes__privileget__last)) +(assert (forall ((?i___1 Int)) (let ((?v_0 (a.select (a.select keyedop field.keyboard__datat.text) ?i___1))) (=> (and (<= keyboard__datai__first ?i___1) (<= ?i___1 keyboard__datai__last)) (and (<= character__first ?v_0) (<= ?v_0 character__last)))))) +(assert (<= keyboard__datalengtht__first (a.select keyedop field.keyboard__datat.length))) +(assert (<= (a.select keyedop field.keyboard__datat.length) keyboard__datalengtht__last)) +(assert (ispresent theadmin)) +(assert (<= datai__first loop__2__i)) +(assert (<= loop__2__i datai__last)) +(assert (<= loop__2__i (a.select keyedop__entry__loop__2 field.keyboard__datat.length))) +(assert (<= opt__first loop__1__op)) +(assert (<= loop__1__op opt__last)) +(assert (<= loop__1__op opt__last)) +(assert (<= keyboard__datai__first loop__2__i)) +(assert (<= loop__2__i keyboard__datai__last)) +(assert (<= datai__first loop__2__i)) +(assert (<= loop__2__i datai__last)) +(assert (<= opt__first loop__1__op)) +(assert (<= loop__1__op opt__last)) +(assert (not (not (= (a.select (a.select (a.select optokeyed loop__1__op) field.datat.text) loop__2__i) (a.select (a.select keyedop field.keyboard__datat.text) loop__2__i))))) +(assert (not (= loop__2__i (a.select keyedop__entry__loop__2 field.keyboard__datat.length)))) +(assert (let ((?v_6 (<= opt__first loop__1__op)) (?v_7 (<= loop__1__op opt__last)) (?v_1 (a.select keyedop field.keyboard__datat.length)) (?v_2 (a.select theadmin field.t.rolepresent)) (?v_3 (a.select theadmin field.t.currentop)) (?v_0 (+ loop__2__i 1))) (let ((?v_4 (<= datai__first ?v_0)) (?v_5 (<= ?v_0 datai__last))) (not (and ?v_6 ?v_7 ?v_4 ?v_5 (<= ?v_0 ?v_1) (<= datai__first ?v_1) (<= ?v_1 datai__last) (= keyedop keyedop__entry__loop__2) (<= privtypes__adminprivileget__first ?v_2) (<= ?v_2 privtypes__adminprivileget__last) (= theop nullop) (<= opandnullt__first ?v_3) (<= ?v_3 opandnullt__last) (<= privtypes__privileget__first ?v_2) (<= ?v_2 privtypes__privileget__last) (forall ((?i___1 Int)) (let ((?v_8 (a.select (a.select keyedop field.keyboard__datat.text) ?i___1))) (=> (and (<= keyboard__datai__first ?i___1) (<= ?i___1 keyboard__datai__last)) (and (<= character__first ?v_8) (<= ?v_8 character__last))))) (<= keyboard__datalengtht__first ?v_1) (<= ?v_1 keyboard__datalengtht__last) (ispresent theadmin) ?v_4 ?v_5 (<= ?v_0 (a.select keyedop__entry__loop__2 field.keyboard__datat.length)) ?v_6 ?v_7 ?v_7))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/parametric-lists.smt2 b/test/regress/regress1/quantifiers/parametric-lists.smt2 new file mode 100644 index 000000000..c45152d6f --- /dev/null +++ b/test/regress/regress1/quantifiers/parametric-lists.smt2 @@ -0,0 +1,44 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-datatypes (T) ((List (cons (head T) (tail (List T))) (nil)))) +(declare-datatypes () ((KV (kv (key Int) (value Int)) (nilKV)))) ; key value pair +(declare-fun mapper ((List Int)) (List KV)) +(assert + (forall + ((input (List Int))) + (ite + (= input (as nil (List Int))) + (= (as nil (List KV)) (mapper input)) + (= (cons (kv 0 (head input)) (mapper (tail input))) (mapper input)) + ) + ) +) +(declare-fun reduce ((List KV)) Int) +(assert + (forall + ((inputk (List KV))) + (ite + (= inputk (as nil (List KV))) + (= 0 (reduce inputk)) + (= (+ (value (head inputk)) (reduce (tail inputk))) (reduce inputk)) + ) + ) +) +(declare-fun sum ((List Int)) Int) +(assert + (forall + ((input (List Int))) + (ite + (= input (as nil (List Int))) + (= 0 (sum input)) + (= (+ (head input) (sum (tail input))) (sum input)) + ) + ) +) +(assert + (not (= (sum (cons 0 (as nil (List Int)))) (reduce (mapper (cons 0 (as nil (List Int))))))) +) +(check-sat) + diff --git a/test/regress/regress1/quantifiers/psyco-001-bv.smt2 b/test/regress/regress1/quantifiers/psyco-001-bv.smt2 new file mode 100644 index 000000000..e3428de17 --- /dev/null +++ b/test/regress/regress1/quantifiers/psyco-001-bv.smt2 @@ -0,0 +1,76 @@ +(set-logic BV) +(set-info :status sat) +(declare-fun W_S1_V1 () Bool) +(declare-fun W_S1_V2 () Bool) +(declare-fun W_S1_V4 () Bool) +(declare-fun R_S1_V1 () Bool) +(declare-fun R_E1_V1 () Bool) +(declare-fun R_E1_V3 () Bool) +(declare-fun R_E1_V2 () Bool) +(declare-fun R_E1_V4 () Bool) +(declare-fun DISJ_W_S1_R_E1 () Bool) +(declare-fun R_S1_V3 () Bool) +(declare-fun R_S1_V2 () Bool) +(declare-fun R_S1_V4 () Bool) +(declare-fun DISJ_W_S1_R_S1 () Bool) +(declare-fun W_S1_V3 () Bool) +(assert + (let + (($x324 + (forall + ((V4_0 (_ BitVec 32)) (V2_0 (_ BitVec 32)) + (V3_0 (_ BitVec 32)) (V1_0 (_ BitVec 32)) + (MW_S1_V4 Bool) (MW_S1_V2 Bool) + (MW_S1_V3 Bool) (MW_S1_V1 Bool) + (S1_V3_!14 (_ BitVec 32)) (S1_V3_!20 (_ BitVec 32)) + (E1_!11 (_ BitVec 32)) (E1_!16 (_ BitVec 32)) + (E1_!17 (_ BitVec 32)) (S1_V1_!15 (_ BitVec 32)) + (S1_V1_!21 (_ BitVec 32)) (S1_V2_!13 (_ BitVec 32)) + (S1_V2_!19 (_ BitVec 32)) (S1_V4_!12 (_ BitVec 32)) + (S1_V4_!18 (_ BitVec 32))) + (let + (($x267 + (and (= (ite MW_S1_V4 S1_V4_!12 V4_0) (ite MW_S1_V4 S1_V4_!18 V4_0)) + (= E1_!16 (ite MW_S1_V1 S1_V1_!21 E1_!17)) + (= (ite MW_S1_V3 S1_V3_!14 V3_0) (ite MW_S1_V3 S1_V3_!20 V3_0)) + (= (ite MW_S1_V1 S1_V1_!15 E1_!11) (ite MW_S1_V1 S1_V1_!21 E1_!17))))) + (let + (($x297 + (and (or (not R_E1_V4) (= (ite MW_S1_V4 S1_V4_!12 V4_0) V4_0)) + (or (not R_E1_V2) (= (ite MW_S1_V2 S1_V2_!13 V2_0) V2_0)) + (or (not R_E1_V3) (= (ite MW_S1_V3 S1_V3_!14 V3_0) V3_0)) + (or (not R_E1_V1) (= (ite MW_S1_V1 S1_V1_!15 E1_!11) V1_0))))) + (let + (($x310 + (and (or (not R_E1_V4) (= V4_0 (ite MW_S1_V4 S1_V4_!12 V4_0))) + (or (not R_E1_V2) (= V2_0 (ite MW_S1_V2 S1_V2_!13 V2_0))) + (or (not R_E1_V3) (= V3_0 (ite MW_S1_V3 S1_V3_!14 V3_0))) + (or (not R_E1_V1) (= V1_0 (ite MW_S1_V1 S1_V1_!15 E1_!11)))))) + (let + (($x321 + (and + (or (not (or (not R_S1_V1) (= E1_!17 E1_!11))) (= S1_V3_!20 S1_V3_!14)) + (or (not $x310) (= E1_!11 E1_!16)) + (= E1_!11 E1_!17) (or (not $x297) (= E1_!16 E1_!17)) + (or (not (or (not R_S1_V1) (= E1_!17 E1_!11))) (= S1_V1_!21 S1_V1_!15)) + (or (not (or (not R_S1_V1) (= E1_!17 E1_!11))) (= S1_V2_!19 S1_V2_!13)) + (or (not (or (not R_S1_V1) (= E1_!17 E1_!11))) (= S1_V4_!18 S1_V4_!12)) + (or (not MW_S1_V4) W_S1_V4) + (or (not MW_S1_V2) W_S1_V2) + (or (not MW_S1_V1) W_S1_V1)))) + (or (not $x321) $x267)))))))) + (let + (($x40 + (or (and W_S1_V4 R_E1_V4) + (and W_S1_V2 R_E1_V2) R_E1_V3 + (and W_S1_V1 R_E1_V1)))) + (let (($x42 (= DISJ_W_S1_R_E1 (not $x40)))) + (let + (($x37 + (or (and W_S1_V4 R_S1_V4) + (and W_S1_V2 R_S1_V2) R_S1_V3 + (and W_S1_V1 R_S1_V1)))) + (let (($x39 (= DISJ_W_S1_R_S1 (not $x37)))) (and W_S1_V3 $x39 $x42 $x324))))))) +(check-sat) +(exit) + diff --git a/test/regress/regress1/quantifiers/psyco-107-bv.smt2 b/test/regress/regress1/quantifiers/psyco-107-bv.smt2 new file mode 100644 index 000000000..82b54a231 --- /dev/null +++ b/test/regress/regress1/quantifiers/psyco-107-bv.smt2 @@ -0,0 +1,162 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=eq-boundary +; EXPECT: unsat +(set-logic BV) +(set-info :status unsat) +(declare-fun W_S1_V6 () Bool) +(declare-fun W_S1_V4 () Bool) +(declare-fun W_S1_V2 () Bool) +(declare-fun W_S1_V3 () Bool) +(declare-fun W_S1_V1 () Bool) +(declare-fun R_E2_V1 () Bool) +(declare-fun R_E2_V3 () Bool) +(declare-fun R_E1_V3 () Bool) +(declare-fun R_E1_V1 () Bool) +(declare-fun R_E1_V6 () Bool) +(declare-fun R_E1_V4 () Bool) +(declare-fun R_E1_V5 () Bool) +(declare-fun R_E1_V2 () Bool) +(declare-fun DISJ_W_S1_R_E1 () Bool) +(declare-fun R_S1_V6 () Bool) +(declare-fun R_S1_V4 () Bool) +(declare-fun R_S1_V5 () Bool) +(declare-fun R_S1_V2 () Bool) +(declare-fun R_S1_V3 () Bool) +(declare-fun R_S1_V1 () Bool) +(declare-fun DISJ_W_S1_R_S1 () Bool) +(declare-fun R_E2_V6 () Bool) +(declare-fun R_E2_V4 () Bool) +(declare-fun R_E2_V5 () Bool) +(declare-fun R_E2_V2 () Bool) +(declare-fun DISJ_W_S1_R_E2 () Bool) +(declare-fun W_S1_V5 () Bool) +(assert + (let + (($x59848 + (forall + ((V1_0 (_ BitVec 32)) (V3_0 (_ BitVec 32)) + (V2_0 (_ BitVec 32)) (V5_0 (_ BitVec 32)) + (V4_0 (_ BitVec 32)) (V6_0 (_ BitVec 32)) + (MW_S1_V1 Bool) (MW_S1_V3 Bool) + (MW_S1_V2 Bool) (MW_S1_V5 Bool) + (MW_S1_V4 Bool) (MW_S1_V6 Bool) + (S1_V1_!5000 (_ BitVec 32)) (S1_V3_!5001 (_ BitVec 32)) + (S1_V2_!5002 (_ BitVec 32)) (E1_!4994 (_ BitVec 32)) + (E1_!4997 (_ BitVec 32)) (E1_!4999 (_ BitVec 32)) + (S1_V5_!5003 (_ BitVec 32)) (E2_!4995 (_ BitVec 32)) + (E2_!4996 (_ BitVec 32)) (E2_!4998 (_ BitVec 32)) + (S1_V4_!5004 (_ BitVec 32)) (S1_V6_!5005 (_ BitVec 32))) + (let ((?x62719 (ite MW_S1_V6 S1_V6_!5005 V6_0))) + (let (($x60064 (= V6_0 ?x62719))) + (let ((?x61425 (ite MW_S1_V4 S1_V4_!5004 V4_0))) + (let (($x59873 (= V4_0 ?x61425))) + (let ((?x59861 (ite MW_S1_V5 S1_V5_!5003 V5_0))) + (let (($x62312 (= V5_0 ?x59861))) + (let ((?x60966 (ite MW_S1_V2 S1_V2_!5002 V2_0))) + (let (($x61331 (= V2_0 ?x60966))) + (let ((?x62280 (ite MW_S1_V3 S1_V3_!5001 E2_!4998))) + (let ((?x60903 (bvadd (_ bv1 32) ?x62280))) + (let (($x61268 (= E2_!4996 ?x60903))) + (let ((?x60065 (ite MW_S1_V1 S1_V1_!5000 E1_!4999))) + (let (($x60169 (= E1_!4994 ?x60065))) + (let (($x62661 (and $x60169 $x61268 $x61331 $x62312 $x59873 $x60064))) + (let ((?x62301 (bvadd (bvneg (_ bv1 32)) ?x61425))) + (let (($x61124 (bvsge ?x62280 ?x62301))) + (let ((?x61096 (bvadd (bvneg (_ bv1 32)) ?x60966))) + (let (($x60960 (bvsge ?x60065 ?x61096))) + (let (($x62453 (bvsle V2_0 E1_!4999))) + (let (($x61140 (not $x62453))) + (let (($x60239 (bvsle V4_0 E2_!4998))) + (let (($x61367 (not $x60239))) + (let (($x59857 (bvsle V2_0 E1_!4997))) + (let (($x62570 (not $x59857))) + (let ((?x62418 (bvadd (bvneg (_ bv1 32)) V2_0))) + (let (($x60189 (bvsge E1_!4994 ?x62418))) + (let (($x62421 (bvsge E2_!4996 V4_0))) + (let (($x60898 (bvsle V2_0 E1_!4994))) + (let (($x59938 (not $x60898))) + (let (($x62400 (bvsle V4_0 E2_!4995))) + (let (($x60971 (not $x62400))) + (let + (($x62394 + (and $x60971 $x59938 $x62421 $x60189 $x62570 $x61367 $x61140 $x60960 + $x61124))) + (let (($x62485 (not $x62394))) + (let (($x60905 (not MW_S1_V6))) + (let (($x61285 (or $x60905 W_S1_V6))) + (let (($x61317 (not MW_S1_V4))) + (let (($x60137 (or $x61317 W_S1_V4))) + (let (($x62306 (not MW_S1_V2))) + (let (($x62708 (or $x62306 W_S1_V2))) + (let (($x62310 (not MW_S1_V3))) + (let (($x60291 (or $x62310 W_S1_V3))) + (let (($x62641 (not MW_S1_V1))) + (let (($x61174 (or $x62641 W_S1_V1))) + (let (($x62627 (= E2_!4998 E2_!4995))) + (let (($x60904 (= E1_!4997 E1_!4994))) + (let (($x128 (not R_E2_V1))) + (let (($x60161 (or $x128 $x60904))) + (let (($x62415 (not $x60161))) + (let (($x62645 (or $x62415 $x62627))) + (let (($x60924 (= E2_!4996 E2_!4998))) + (let (($x62711 (= E2_!4995 V3_0))) + (let (($x130 (not R_E2_V3))) + (let (($x62623 (or $x130 $x62711))) + (let (($x60954 (= E1_!4994 E1_!4997))) + (let (($x59868 (or $x128 $x60954))) + (let (($x62319 (and $x59868 $x62623))) + (let (($x62554 (not $x62319))) + (let (($x60985 (or $x62554 $x60924))) + (let (($x62256 (= E2_!4996 E2_!4995))) + (let (($x62540 (not $x62623))) + (let (($x60968 (or $x62540 $x62256))) + (let (($x62486 (= E1_!4999 E1_!4997))) + (let (($x60109 (= E2_!4998 V3_0))) + (let (($x115 (not R_E1_V3))) + (let (($x60129 (or $x115 $x60109))) + (let (($x60976 (= E1_!4997 V1_0))) + (let (($x113 (not R_E1_V1))) + (let (($x62568 (or $x113 $x60976))) + (let (($x60942 (and $x62568 $x60129))) + (let (($x60209 (not $x60942))) + (let (($x62263 (or $x60209 $x62486))) + (let (($x60965 (= E1_!4999 E1_!4994))) + (let (($x62348 (or $x60209 $x60965))) + (let + (($x60285 + (and $x60954 $x62348 $x62263 $x60968 $x60985 $x62645 $x61174 $x60291 + $x62708 $x60137 $x61285))) + (let (($x62430 (not $x60285))) (or $x62430 $x62485 $x62661))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + (let (($x56 (and W_S1_V6 R_E1_V6))) + (let (($x54 (and W_S1_V4 R_E1_V4))) + (let (($x50 (and W_S1_V2 R_E1_V2))) + (let (($x48 (and W_S1_V3 R_E1_V3))) + (let (($x46 (and W_S1_V1 R_E1_V1))) + (let (($x69 (or $x46 $x48 $x50 R_E1_V5 $x54 $x56))) + (let (($x70 (not $x69))) + (let (($x71 (= DISJ_W_S1_R_E1 $x70))) + (let (($x40 (and W_S1_V6 R_S1_V6))) + (let (($x38 (and W_S1_V4 R_S1_V4))) + (let (($x34 (and W_S1_V2 R_S1_V2))) + (let (($x32 (and W_S1_V3 R_S1_V3))) + (let (($x30 (and W_S1_V1 R_S1_V1))) + (let (($x66 (or $x30 $x32 $x34 R_S1_V5 $x38 $x40))) + (let (($x67 (not $x66))) + (let (($x68 (= DISJ_W_S1_R_S1 $x67))) + (let (($x24 (and W_S1_V6 R_E2_V6))) + (let (($x21 (and W_S1_V4 R_E2_V4))) + (let (($x16 (and W_S1_V2 R_E2_V2))) + (let (($x13 (and W_S1_V3 R_E2_V3))) + (let (($x10 (and W_S1_V1 R_E2_V1))) + (let (($x63 (or $x10 $x13 $x16 R_E2_V5 $x21 $x24))) + (let (($x64 (not $x63))) + (let (($x65 (= DISJ_W_S1_R_E2 $x64))) + (let (($x130 (not R_E2_V3))) + (let (($x115 (not R_E1_V3))) + (let (($x113 (not R_E1_V1))) + (let (($x60916 (and $x113 $x115))) + (let (($x62291 (or $x60916 $x130))) + (and $x62291 W_S1_V5 $x65 $x68 $x71 $x59848)))))))))))))))))))))))))))))))) +(assert R_E2_V3) +(check-sat) +(exit) + diff --git a/test/regress/regress1/quantifiers/psyco-196.smt2 b/test/regress/regress1/quantifiers/psyco-196.smt2 new file mode 100644 index 000000000..fef1a24c6 --- /dev/null +++ b/test/regress/regress1/quantifiers/psyco-196.smt2 @@ -0,0 +1,422 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic LIA) +(set-info :status sat) +(declare-fun W_S1_V5 () Bool) +(declare-fun W_S1_V4 () Bool) +(declare-fun W_S1_V6 () Bool) +(declare-fun W_S1_V1 () Bool) +(declare-fun W_S1_V3 () Bool) +(declare-fun W_S1_V2 () Bool) +(declare-fun R_S1_V5 () Bool) +(declare-fun R_S1_V4 () Bool) +(declare-fun R_S1_V6 () Bool) +(declare-fun R_S1_V1 () Bool) +(declare-fun R_S1_V3 () Bool) +(declare-fun R_S1_V2 () Bool) +(declare-fun R_E2_V1 () Bool) +(declare-fun R_E1_V1 () Bool) +(declare-fun R_E1_V3 () Bool) +(declare-fun R_E2_V3 () Bool) +(assert + (let + (($x62242 + (forall + ((V2_0 Int) (V6_0 Int) + (V4_0 Int) (V5_0 Int) + (S1_V3_!5556 Int) (S1_V3_!5562 Int) + (S1_V3_!5571 Int) (S1_V3_!5577 Int) + (E1_!5552 Int) (E1_!5567 Int) + (E1_!5569 Int) (S1_V2_!5555 Int) + (S1_V2_!5561 Int) (S1_V2_!5570 Int) + (S1_V2_!5576 Int) (S1_V5_!5560 Int) + (S1_V5_!5566 Int) (S1_V5_!5575 Int) + (S1_V5_!5581 Int) (S1_V4_!5559 Int) + (S1_V4_!5565 Int) (S1_V4_!5574 Int) + (S1_V4_!5580 Int) (S1_V6_!5558 Int) + (S1_V6_!5564 Int) (S1_V6_!5573 Int) + (S1_V6_!5579 Int) (E2_!5553 Int) + (E2_!5554 Int) (E2_!5568 Int) + (S1_V1_!5557 Int) (S1_V1_!5563 Int) + (S1_V1_!5572 Int) (S1_V1_!5578 Int)) + (let (($x59864 (= S1_V5_!5566 S1_V5_!5581))) + (let (($x59925 (not W_S1_V5))) + (let (($x62779 (or $x59925 $x59864))) + (let (($x62200 (= S1_V4_!5565 S1_V4_!5580))) + (let (($x59923 (not W_S1_V4))) + (let (($x62447 (or $x59923 $x62200))) + (let (($x62602 (= S1_V6_!5564 S1_V6_!5579))) + (let (($x62610 (not W_S1_V6))) + (let (($x62230 (or $x62610 $x62602))) + (let (($x61214 (= S1_V1_!5563 S1_V1_!5578))) + (let (($x60986 (= S1_V3_!5562 S1_V3_!5577))) + (let (($x62444 (= S1_V2_!5561 S1_V2_!5576))) + (let (($x62507 (not W_S1_V2))) + (let (($x62441 (or $x62507 $x62444))) + (let + (($x62532 + (and $x62441 + (ite W_S1_V3 $x60986 + (= (ite W_S1_V3 S1_V3_!5556 E2_!5554) (+ (- 1) E2_!5568))) + (ite W_S1_V1 $x61214 + (= E1_!5552 (+ 1 (ite W_S1_V1 S1_V1_!5572 E1_!5569)))) $x62230 $x62447 + $x62779))) + (let ((?x62367 (ite W_S1_V1 S1_V1_!5572 E1_!5569))) + (let ((?x60865 (+ 1 ?x62367))) + (let ((?x62511 (ite W_S1_V1 S1_V1_!5578 ?x60865))) + (let ((?x60218 (ite W_S1_V3 S1_V3_!5556 E2_!5554))) + (let ((?x60222 (+ 1 ?x60218))) + (let ((?x62533 (ite W_S1_V3 S1_V3_!5562 ?x60222))) + (let + (($x62746 + (and (not (<= V4_0 E2_!5553)) + (not (<= V2_0 E1_!5552)) + (not (<= V4_0 E2_!5554)) + (not (<= (ite W_S1_V4 S1_V4_!5559 V4_0) ?x60222)) + (>= ?x62533 (+ (- 1) (ite W_S1_V4 S1_V4_!5565 V4_0))) + (>= (ite W_S1_V1 S1_V1_!5563 E1_!5552) + (+ (- 1) (ite W_S1_V2 S1_V2_!5561 V2_0))) + (not (<= V2_0 E1_!5567)) + (not (<= V4_0 E2_!5568)) + (not (<= V2_0 E1_!5569)) + (not (<= (ite W_S1_V2 S1_V2_!5570 V2_0) ?x60865)) + (>= ?x62511 (+ (- 1) (ite W_S1_V2 S1_V2_!5576 V2_0))) + (>= (ite W_S1_V3 S1_V3_!5577 E2_!5568) + (+ (- 1) (ite W_S1_V4 S1_V4_!5580 V4_0)))))) + (let (($x62780 (= S1_V1_!5578 S1_V1_!5572))) + (let (($x161 (not R_S1_V5))) + (let (($x62589 (or $x161 (= (ite W_S1_V5 S1_V5_!5575 V5_0) V5_0)))) + (let (($x159 (not R_S1_V4))) + (let (($x62548 (or $x159 (= (ite W_S1_V4 S1_V4_!5574 V4_0) V4_0)))) + (let (($x157 (not R_S1_V6))) + (let (($x62737 (or $x157 (= (ite W_S1_V6 S1_V6_!5573 V6_0) V6_0)))) + (let (($x153 (not R_S1_V3))) + (let + (($x62224 (or $x153 (= (ite W_S1_V3 S1_V3_!5571 E2_!5568) E2_!5568)))) + (let (($x151 (not R_S1_V2))) + (let (($x62641 (or $x151 (= (ite W_S1_V2 S1_V2_!5570 V2_0) V2_0)))) + (let + (($x60228 + (and $x62641 $x62224 + (or (not R_S1_V1) (= ?x62367 (+ (- 1) E1_!5569))) $x62737 $x62548 + $x62589))) + (let (($x62356 (not $x60228))) + (let (($x62680 (= S1_V1_!5578 S1_V1_!5563))) + (let (($x62272 (or $x161 $x59925 (= S1_V5_!5575 S1_V5_!5560)))) + (let (($x61083 (= S1_V4_!5574 S1_V4_!5559))) + (let (($x62455 (or $x159 $x59923 $x61083))) + (let (($x60917 (= S1_V6_!5573 S1_V6_!5558))) + (let (($x62584 (or $x157 $x62610 $x60917))) + (let (($x59905 (= S1_V2_!5570 S1_V2_!5555))) + (let (($x62549 (or $x151 $x62507 $x59905))) + (let + (($x62675 + (and $x62549 (or $x153 (= (ite W_S1_V3 S1_V3_!5571 E2_!5568) ?x60222)) + (or (not R_S1_V1) + (= ?x62367 (+ (- 1) (ite W_S1_V1 S1_V1_!5557 E1_!5552)))) $x62584 + $x62455 $x62272))) + (let (($x59892 (= S1_V1_!5578 S1_V1_!5557))) + (let + (($x60942 (or $x153 (= (ite W_S1_V3 S1_V3_!5571 E2_!5568) E2_!5554)))) + (let + (($x62564 + (and $x62641 $x60942 + (or (not R_S1_V1) (= ?x62367 (+ (- 1) E1_!5552))) $x62737 $x62548 + $x62589))) + (let (($x59819 (not $x62564))) + (let (($x60234 (= S1_V1_!5563 S1_V1_!5572))) + (let (($x61232 (or $x161 (= (ite W_S1_V5 S1_V5_!5560 V5_0) V5_0)))) + (let (($x61254 (or $x159 (= (ite W_S1_V4 S1_V4_!5559 V4_0) V4_0)))) + (let (($x59994 (or $x157 (= (ite W_S1_V6 S1_V6_!5558 V6_0) V6_0)))) + (let (($x155 (not R_S1_V1))) + (let + (($x62420 (or $x155 (= (ite W_S1_V1 S1_V1_!5557 E1_!5552) E1_!5569)))) + (let (($x62368 (or $x151 (= (ite W_S1_V2 S1_V2_!5555 V2_0) V2_0)))) + (let + (($x62830 + (not + (and $x62368 (or $x153 (= ?x60218 (+ (- 1) E2_!5568))) $x62420 $x59994 + $x61254 $x61232)))) + (let (($x62636 (= S1_V1_!5563 S1_V1_!5557))) + (let + (($x59733 (or $x155 (= (ite W_S1_V1 S1_V1_!5557 E1_!5552) E1_!5552)))) + (let + (($x62306 + (not + (and $x62368 (or $x153 (= ?x60218 (+ (- 1) E2_!5554))) $x59733 $x59994 + $x61254 $x61232)))) + (let (($x60134 (= S1_V1_!5557 S1_V1_!5572))) + (let + (($x59719 + (not + (and (or $x153 (= E2_!5554 E2_!5568)) (or $x155 (= E1_!5552 E1_!5569)))))) + (let (($x61406 (= E2_!5554 E2_!5568))) + (let (($x59878 (not (or (not R_E2_V1) (= E1_!5552 E1_!5567))))) + (let (($x59949 (or $x59878 $x61406))) + (let (($x62775 (or $x59878 (= E2_!5553 E2_!5568)))) + (let (($x59743 (= E2_!5553 E2_!5554))) + (let (($x62428 (= S1_V6_!5573 S1_V6_!5579))) + (let (($x60152 (or $x161 (= V5_0 (ite W_S1_V5 S1_V5_!5575 V5_0))))) + (let (($x60212 (or $x159 (= V4_0 (ite W_S1_V4 S1_V4_!5574 V4_0))))) + (let (($x61260 (or $x157 (= V6_0 (ite W_S1_V6 S1_V6_!5573 V6_0))))) + (let + (($x60887 (or $x153 (= E2_!5568 (ite W_S1_V3 S1_V3_!5571 E2_!5568))))) + (let (($x62275 (or $x151 (= V2_0 (ite W_S1_V2 S1_V2_!5570 V2_0))))) + (let + (($x61258 + (or + (not + (and $x62275 $x60887 + (or $x155 (= E1_!5569 ?x60865)) $x61260 $x60212 $x60152)) $x62428))) + (let + (($x61266 + (not + (and (or $x153 (= E2_!5568 E2_!5554)) (or $x155 (= E1_!5569 E1_!5552)))))) + (let (($x61122 (= S1_V5_!5560 S1_V5_!5575))) + (let (($x59790 (or $x161 $x59925 $x61122))) + (let (($x62797 (or $x159 $x59923 (= S1_V4_!5559 S1_V4_!5574)))) + (let (($x62684 (or $x157 $x62610 (= S1_V6_!5558 S1_V6_!5573)))) + (let (($x62354 (or $x151 $x62507 (= S1_V2_!5555 S1_V2_!5570)))) + (let + (($x60910 + (and $x62354 + (or $x153 (= ?x60218 (+ (- 1) (ite W_S1_V3 S1_V3_!5571 E2_!5568)))) + (or $x155 (= (ite W_S1_V1 S1_V1_!5557 E1_!5552) ?x60865)) $x62684 + $x62797 $x59790))) + (let (($x59844 (not $x60910))) + (let (($x62494 (= S1_V5_!5560 S1_V5_!5581))) + (let + (($x62623 (or $x153 (= E2_!5554 (ite W_S1_V3 S1_V3_!5571 E2_!5568))))) + (let + (($x61100 + (or + (not + (and $x62275 $x62623 + (or $x155 (= E1_!5552 ?x60865)) $x61260 $x60212 $x60152)) $x62494))) + (let (($x60862 (= S1_V5_!5560 S1_V5_!5566))) + (let (($x62353 (or $x161 (= V5_0 (ite W_S1_V5 S1_V5_!5560 V5_0))))) + (let (($x60875 (or $x159 (= V4_0 (ite W_S1_V4 S1_V4_!5559 V4_0))))) + (let (($x62491 (or $x157 (= V6_0 (ite W_S1_V6 S1_V6_!5558 V6_0))))) + (let + (($x62399 (or $x155 (= E1_!5552 (ite W_S1_V1 S1_V1_!5557 E1_!5552))))) + (let (($x62431 (or $x151 (= V2_0 (ite W_S1_V2 S1_V2_!5555 V2_0))))) + (let + (($x62297 + (or + (not + (and $x62431 (or $x153 (= E2_!5554 ?x60222)) $x62399 $x62491 $x60875 + $x62353)) $x60862))) + (let (($x60874 (= S1_V2_!5570 S1_V2_!5576))) + (let + (($x62369 + (or + (not + (and $x62275 $x60887 + (or $x155 (= E1_!5569 ?x60865)) $x61260 $x60212 $x60152)) $x60874))) + (let (($x62594 (= S1_V2_!5555 S1_V2_!5576))) + (let + (($x59910 + (or + (not + (and $x62275 $x62623 + (or $x155 (= E1_!5552 ?x60865)) $x61260 $x60212 $x60152)) $x62594))) + (let (($x62531 (= E1_!5569 E1_!5567))) + (let (($x59835 (= E1_!5552 E1_!5569))) + (let (($x62312 (= E1_!5552 E1_!5567))) + (let + (($x62715 + (and (or $x59719 (= S1_V3_!5556 S1_V3_!5571)) + (or $x62306 (= S1_V3_!5562 S1_V3_!5556)) + (or $x62830 (= S1_V3_!5562 S1_V3_!5571)) + (or $x59819 (= S1_V3_!5577 S1_V3_!5556)) + (or (not $x62675) (= S1_V3_!5577 S1_V3_!5562)) + (or $x62356 (= S1_V3_!5577 S1_V3_!5571)) $x62312 $x59835 $x62531 + $x59910 (or $x62306 (= S1_V2_!5561 S1_V2_!5555)) + (or $x62830 (= S1_V2_!5561 S1_V2_!5570)) + (or $x59844 $x62444) + (or $x61266 $x59905) $x62369 $x62297 + (or $x59719 $x61122) $x61100 + (or $x62830 (= S1_V5_!5566 S1_V5_!5575)) + (or $x59844 $x59864) + (or $x62356 (= S1_V5_!5581 S1_V5_!5575)) + (or $x62306 (= S1_V4_!5565 S1_V4_!5559)) + (or $x62830 (= S1_V4_!5565 S1_V4_!5574)) + (or $x59844 $x62200) + (or $x61266 $x61083) + (or $x59819 (= S1_V4_!5580 S1_V4_!5559)) + (or $x62356 (= S1_V4_!5580 S1_V4_!5574)) + (or $x62306 (= S1_V6_!5564 S1_V6_!5558)) + (or $x62830 (= S1_V6_!5564 S1_V6_!5573)) + (or $x59844 $x62602) + (or $x61266 $x60917) $x61258 + (or $x59819 (= S1_V6_!5579 S1_V6_!5558)) $x59743 $x62775 $x59949 + (or $x59719 $x60134) + (or $x62306 $x62636) + (or $x62830 $x60234) + (or $x59819 $x59892) + (or (not $x62675) $x62680) + (or $x62356 $x62780)))) + (or (not $x62715) (not $x62746) $x62532))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + (let (($x13 (or W_S1_V2 W_S1_V3 W_S1_V1 W_S1_V6 W_S1_V4 W_S1_V5))) + (let (($x65 (not R_E1_V1))) + (let (($x63 (not R_E1_V3))) + (let (($x84 (not R_E2_V3))) (and $x84 $x63 $x65 $x13 $x62242))))))) +(assert (not (and (not W_S1_V4) (not W_S1_V3)))) +(assert (not (and (not W_S1_V1) (not W_S1_V2)))) +(assert (not (and (not R_S1_V3) (not R_S1_V1) (not W_S1_V4) (not W_S1_V2)))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x161 (not R_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x155 (not R_S1_V1))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x155 $x157 $x159 $x161 $x62714))))))))) +(assert + (let (($x62610 (not W_S1_V6))) + (let (($x62507 (not W_S1_V2))) + (let (($x59925 (not W_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x155 (not R_S1_V1))) + (let (($x153 (not R_S1_V3))) + (not (and $x153 $x155 $x159 $x59925 $x62507 $x62610))))))))) +(assert + (let (($x161 (not R_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x155 (not R_S1_V1))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x155 $x157 $x159 $x161))))))))) +(assert (not (and W_S1_V3 (not R_S1_V3) (not R_S1_V1) (not W_S1_V2)))) +(assert (not (and W_S1_V3 W_S1_V1 (not R_S1_V3) (not R_S1_V1)))) +(assert + (let (($x62232 (not W_S1_V1))) + (let (($x59925 (not W_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x157 $x159 $x59925 $x62232))))))))) +(assert + (let (($x62610 (not W_S1_V6))) + (let (($x62232 (not W_S1_V1))) + (let (($x59925 (not W_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x159 $x59925 $x62232 $x62610))))))))) +(assert + (let (($x62610 (not W_S1_V6))) + (let (($x59923 (not W_S1_V4))) + (let (($x161 (not R_S1_V5))) + (let (($x155 (not R_S1_V1))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x155 $x161 $x59923 $x62610))))))))) +(assert + (let (($x62610 (not W_S1_V6))) + (let (($x62232 (not W_S1_V1))) + (let (($x161 (not R_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x159 $x161 $x62232 $x62610))))))))) +(assert + (let (($x62232 (not W_S1_V1))) + (let (($x59925 (not W_S1_V5))) + (let (($x59923 (not W_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x157 $x59923 $x59925 $x62232))))))))) +(assert + (let (($x62610 (not W_S1_V6))) + (let (($x59925 (not W_S1_V5))) + (let (($x59923 (not W_S1_V4))) + (let (($x155 (not R_S1_V1))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x155 $x59923 $x59925 $x62610))))))))) +(assert + (let (($x59923 (not W_S1_V4))) + (let (($x161 (not R_S1_V5))) + (let (($x157 (not R_S1_V6))) + (let (($x155 (not R_S1_V1))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x155 $x157 $x161 $x59923))))))))) +(assert + (let (($x62232 (not W_S1_V1))) + (let (($x59923 (not W_S1_V4))) + (let (($x161 (not R_S1_V5))) + (let (($x157 (not R_S1_V6))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x157 $x161 $x59923 $x62232))))))))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x62507 (not W_S1_V2))) + (let (($x161 (not R_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x155 (not R_S1_V1))) + (not (and $x155 $x157 $x159 $x161 $x62507 $x62714))))))))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x62610 (not W_S1_V6))) + (let (($x161 (not R_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x155 (not R_S1_V1))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x155 $x159 $x161 $x62610 $x62714))))))))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x62610 (not W_S1_V6))) + (let (($x62507 (not W_S1_V2))) + (let (($x161 (not R_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x155 (not R_S1_V1))) + (not (and $x155 $x159 $x161 $x62507 $x62610 $x62714))))))))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x59925 (not W_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x155 (not R_S1_V1))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x155 $x157 $x159 $x59925 $x62714))))))))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x62507 (not W_S1_V2))) + (let (($x59925 (not W_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x155 (not R_S1_V1))) + (not (and $x155 $x157 $x159 $x59925 $x62507 $x62714))))))))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x62610 (not W_S1_V6))) + (let (($x59925 (not W_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x155 (not R_S1_V1))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x155 $x159 $x59925 $x62610 $x62714))))))))) +(assert + (let (($x62714 (not W_S1_V3))) + (let (($x62610 (not W_S1_V6))) + (let (($x62507 (not W_S1_V2))) + (let (($x59925 (not W_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x155 (not R_S1_V1))) + (not (and $x155 $x159 $x59925 $x62507 $x62610 $x62714))))))))) +(assert + (let (($x62232 (not W_S1_V1))) + (let (($x161 (not R_S1_V5))) + (let (($x159 (not R_S1_V4))) + (let (($x157 (not R_S1_V6))) + (let (($x153 (not R_S1_V3))) + (let (($x151 (not R_S1_V2))) + (not (and $x151 $x153 $x157 $x159 $x161 $x62232))))))))) +(check-sat) + diff --git a/test/regress/regress1/quantifiers/qbv-disequality3.smt2 b/test/regress/regress1/quantifiers/qbv-disequality3.smt2 new file mode 100644 index 000000000..d16157509 --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-disequality3.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (= (bvmul (bvadd x b) a) b))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-simple-2vars-vo.smt2 b/test/regress/regress1/quantifiers/qbv-simple-2vars-vo.smt2 new file mode 100644 index 000000000..c36322aac --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-simple-2vars-vo.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) +(declare-fun c () (_ BitVec 8)) + +(assert (not (= a #x00))) + +(assert (forall ((x (_ BitVec 8)) (y (_ BitVec 8))) (or +(not (= (bvmul x y) #x0A)) +(not (= (bvadd y a) #x10)) +))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvashr-0.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvashr-0.smt2 new file mode 100644 index 000000000..30e7c2f8b --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvashr-0.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (not (= (bvashr x a) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvashr-1.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvashr-1.smt2 new file mode 100644 index 000000000..c3de64c4c --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvashr-1.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (not (= (bvashr a x) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvcomp.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvcomp.smt2 new file mode 100644 index 000000000..3b55c0b9a --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvcomp.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: unsat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) +(declare-fun c () (_ BitVec 1)) + +(assert (forall ((x (_ BitVec 8))) (not (= (bvcomp x a) ((_ extract 7 7) (bvmul a b)))))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvlshr-1.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvlshr-1.smt2 new file mode 100644 index 000000000..08479d90e --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvlshr-1.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (not (= (bvlshr a x) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvmul-neq.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvmul-neq.smt2 new file mode 100644 index 000000000..9dc9f98ac --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvmul-neq.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (= (bvmul x a) b))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvmul.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvmul.smt2 new file mode 100644 index 000000000..f3dad679b --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvmul.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (not (= (bvmul x a) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-0-neq.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-0-neq.smt2 new file mode 100644 index 000000000..3748eca24 --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-0-neq.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: unsat +(set-logic BV) +(set-info :status unsat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (distinct a b (_ bv0 8))) +(assert (forall ((x (_ BitVec 8))) (= (bvudiv x a) b))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-0.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-0.smt2 new file mode 100644 index 000000000..2cabb502e --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-0.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (distinct a b (_ bv0 8))) +(assert (forall ((x (_ BitVec 8))) (not (= (bvudiv x a) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-1-neq.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-1-neq.smt2 new file mode 100644 index 000000000..a0e1b62c2 --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-1-neq.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full --bv-div-zero-const +; EXPECT: unsat +(set-logic BV) +(set-info :status unsat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (distinct a b (_ bv0 8))) +(assert (forall ((x (_ BitVec 8))) (= (bvudiv a x) b))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-1.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-1.smt2 new file mode 100644 index 000000000..2690a0ac9 --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvudiv-1.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full --bv-div-zero-const +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (distinct a b (_ bv0 8))) +(assert (forall ((x (_ BitVec 8))) (not (= (bvudiv a x) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvurem-1-neq.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvurem-1-neq.smt2 new file mode 100644 index 000000000..871df4827 --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvurem-1-neq.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (= (bvurem a x) b))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-invert-bvurem-1.smt2 b/test/regress/regress1/quantifiers/qbv-test-invert-bvurem-1.smt2 new file mode 100644 index 000000000..22bd306ee --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-invert-bvurem-1.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 8)) +(declare-fun b () (_ BitVec 8)) + +(assert (forall ((x (_ BitVec 8))) (not (= (bvurem a x) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qbv-test-urem-rewrite.smt2 b/test/regress/regress1/quantifiers/qbv-test-urem-rewrite.smt2 new file mode 100644 index 000000000..e57352b8f --- /dev/null +++ b/test/regress/regress1/quantifiers/qbv-test-urem-rewrite.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --cbqi-bv --cbqi-bv-ineq=keep --no-cbqi-full +; EXPECT: sat +(set-logic BV) +(set-info :status sat) +(declare-fun a () (_ BitVec 4)) +(declare-fun b () (_ BitVec 4)) + +(assert (forall ((x (_ BitVec 4))) (not (= (bvurem x a) b)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/qcft-javafe.filespace.TreeWalker.006.smt2 b/test/regress/regress1/quantifiers/qcft-javafe.filespace.TreeWalker.006.smt2 new file mode 100644 index 000000000..2a5eb34a7 --- /dev/null +++ b/test/regress/regress1/quantifiers/qcft-javafe.filespace.TreeWalker.006.smt2 @@ -0,0 +1,432 @@ +; COMMAND-LINE: --qcf-tconstraint +; EXPECT: unsat +(set-logic AUFLIA) +(set-info :source | + Simplify front end test suite. + This benchmark was translated by Michal Moskal. +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun EC_134.22_134.22 () Int) +(declare-fun integralOr (Int Int) Int) +(declare-fun this_95.46_87.8_0_95.46 () Int) +(declare-fun EC_183.16_183.16 () Int) +(declare-fun arrayShapeMore (Int Int) Int) +(declare-fun integralAnd (Int Int) Int) +(declare-fun T_.TYPE () Int) +(declare-fun EC_156.1_0_158.5_0_159.22_159.22 () Int) +(declare-fun intFirst () Int) +(declare-fun after_192.22_192.22 () Int) +(declare-fun T_javafe.filespace.HashTree () Int) +(declare-fun lookAhead_4.43.19 () Int) +(declare-fun after_90.24_87.8_0_90.24_5.89.17 () Int) +(declare-fun eClosedTime (Int) Int) +(declare-fun int_m9223372036854775808 () Int) +(declare-fun C_87.8 () Int) +(declare-fun int_m2147483648 () Int) +(declare-fun T_java.lang.Comparable () Int) +(declare-fun arrayPosition (Int) Int) +(declare-fun treeName_186.1 () Int) +(declare-fun remainingNodes_loopold_48.26 () Int) +(declare-fun after_189.12_189.12 () Int) +(declare-fun this_159.11_156.1_0_158.5_0_159.11 () Int) +(declare-fun select1 (Int Int) Int) +(declare-fun select2 (Int Int Int) Int) +(declare-fun EC_192.22_192.22 () Int) +(declare-fun L_158.5 () Int) +(declare-fun T_java.util.EscjavaKeyValue () Int) +(declare-fun elems_1_ () Int) +(declare-fun c_loopold_133.5 () Int) +(declare-fun T_long () Int) +(declare-fun EC_121.8_121.8 () Int) +(declare-fun EC_65.1_65.1 () Int) +(declare-fun moreElements_192.1_0_193.28_5.89.17 () Int) +(declare-fun after_121.8_121.8 () Int) +(declare-fun T_javafe.filespace.LookAheadEnum () Int) +(declare-fun lockLE (Int Int) Bool) +(declare-fun classLiteral (Int) Int) +(declare-fun lockLT (Int Int) Bool) +(declare-fun T_javafe.filespace.Tree () Int) +(declare-fun elems_2_ () Int) +(declare-fun EC_189.12_189.12 () Int) +(declare-fun T_float () Int) +(declare-fun alloc () Int) +(declare-fun T_java.io.OutputStream () Int) +(declare-fun EC_87.8_0_89.24_89.24 () Int) +(declare-fun S_194.56 () Int) +(declare-fun asChild (Int Int) Int) +(declare-fun CONCVARSYM (Int) Int) +(declare-fun T_int () Int) +(declare-fun after_65.1_65.1 () Int) +(declare-fun int_2147483647 () Int) +(declare-fun RES_130.35 () Int) +(declare-fun remainingNodes_48.26_1_ () Int) +(declare-fun int_9223372036854775807 () Int) +(declare-fun this () Int) +(declare-fun T_byte () Int) +(declare-fun T_java.lang.System () Int) +(declare-fun store1 (Int Int Int) Int) +(declare-fun store2 (Int Int Int Int) Int) +(declare-fun RES_loopold () Int) +(declare-fun remainingNodes_48.26_2_ () Int) +(declare-fun max (Int) Int) +(declare-fun elems_156.1_0_158.5_0_1_ () Int) +(declare-fun moreElements_pre_5.58.29 () Int) +(declare-fun moreElements_87.8_0_90.24_5.89.17 () Int) +(declare-fun objectToBeConstructed () Int) +(declare-fun T_java.util.Map () Int) +(declare-fun tmp4_156.1_0_158.5_0_163.8 () Int) +(declare-fun T_javafe.filespace.TreeWalker () Int) +(declare-fun after_189.25_189.25 () Int) +(declare-fun integralDiv (Int Int) Int) +(declare-fun i_156.1_0_158.5_0_158.33 () Int) +(declare-fun after_135.35_134.1_0_135.35_5.89.17 () Int) +(declare-fun EC_130.36_130.36 () Int) +(declare-fun RES_121.33_121.33 () Int) +(declare-fun moreElements_loopold_5.58.29 () Int) +(declare-fun RES_134.22_134.22 () Int) +(declare-fun list_210.13 () Int) +(declare-fun EC_189.25_189.25 () Int) +(declare-fun T_java.lang.Class () Int) +(declare-fun T_java.lang.Object () Int) +(declare-fun tmp_156.1_0_158.5_0_161.6 () Int) +(declare-fun remainingChildren_pre_39.26 () Int) +(declare-fun EC_192.1_1_192.45_192.45 () Int) +(declare-fun RES_192.1_1_192.45_192.45 () Int) +(declare-fun RES_156.1_0_158.5_0_160.18_160.18 () Int) +(declare-fun longLast () Int) +(declare-fun termConditional (Int Int Int) Int) +(declare-fun T_java.util.Dictionary () Int) +(declare-fun C_156.1 () Int) +(declare-fun bool_false () Int) +(declare-fun RES_192.22_192.22 () Int) +(declare-fun T_javafe.filespace.FileTree () Int) +(declare-fun alloc_loopold () Int) +(declare-fun Smt.true () Int) +(declare-fun returnsNull_5.79.29 () Int) +(declare-fun c_134.1_0_135.20 () Int) +(declare-fun asLockSet (Int) Int) +(declare-fun integralMod (Int Int) Int) +(declare-fun RES_67.21_67.21 () Int) +(declare-fun RES_156.1_0_158.5_0_159.11_159.11 () Int) +(declare-fun Smt.false () Int) +(declare-fun typeof (Int) Int) +(declare-fun int_18446744073709551615 () Int) +(declare-fun RES_189.12_189.12 () Int) +(declare-fun this_160.18_156.1_0_158.5_0_160.18 () Int) +(declare-fun EC_134.1_0_134.36_134.36 () Int) +(declare-fun RES_89.23 () Int) +(declare-fun RES_134.1_0_134.36_134.36 () Int) +(declare-fun RES_87.8_0_93.28_93.28 () Int) +(declare-fun elementType_5.74.27 () Int) +(declare-fun stringCat (Int Int) Int) +(declare-fun remainingChildren_39.26_1_ () Int) +(declare-fun RES_87.8_0_95.46_95.46 () Int) +(declare-fun lookAheadValid_4.40.20 () Int) +(declare-fun T_boolean () Int) +(declare-fun longFirst () Int) +(declare-fun elems_loopold_156.1_0 () Int) +(declare-fun T_java.util.Hashtable () Int) +(declare-fun elems_loopold () Int) +(declare-fun T_java.util.Properties () Int) +(declare-fun L_87.8 () Int) +(declare-fun RES_68.21_68.21 () Int) +(declare-fun RES_65.1_65.1 () Int) +(declare-fun arrayFresh (Int Int Int Int Int Int Int) Bool) +(declare-fun RES () Int) +(declare-fun elementType_pre_5.74.27 () Int) +(declare-fun L_156.1 () Int) +(declare-fun intLast () Int) +(declare-fun RES_130.36_130.36 () Int) +(declare-fun RES_87.8_0_90.24_90.24 () Int) +(declare-fun arrayType () Int) +(declare-fun RES_189.25_189.25 () Int) +(declare-fun boolEq (Int Int) Bool) +(declare-fun EC_134.1_0_135.35_135.35 () Int) +(declare-fun after_193.28_192.1_0_193.28_5.89.17 () Int) +(declare-fun RES_134.1_0_135.35_135.35 () Int) +(declare-fun T_129.49 () Int) +(declare-fun arrayLength (Int) Int) +(declare-fun cast (Int Int) Int) +(declare-fun nextChild_87.8_0_95.5 () Int) +(declare-fun elementType_71.16 () Int) +(declare-fun asElems (Int) Int) +(declare-fun T_javafe.filespace.PreloadedTree () Int) +(declare-fun moreElements_5.58.29 () Int) +(declare-fun T_char () Int) +(declare-fun EC_192.1_0_194.16_194.16 () Int) +(declare-fun owner_pre_6.35.28 () Int) +(declare-fun RES_156.1_0_158.5_0_159.22_159.22 () Int) +(declare-fun EC_140.1_140.1 () Int) +(declare-fun divides (Int Int) Int) +(declare-fun returnsNull_72.16 () Int) +(declare-fun remainingChildren_39.26 () Int) +(declare-fun remainingNodes_68.1 () Int) +(declare-fun T_javafe.filespace.TreeWalker_ArrayEnum () Int) +(declare-fun arg0_194.16_192.1_0_194.16_17.. () Int) +(declare-fun InRange (Int Int) Bool) +(declare-fun moreElements_87.8_0_95.46_5.89.17 () Int) +(declare-fun sorted_157.13 () Int) +(declare-fun moreElements_134.1_0_135.35_5.89.17 () Int) +(declare-fun out_pre_16.83.49 () Int) +(declare-fun elementType_69.24 () Int) +(declare-fun RES_121.8_121.8 () Int) +(declare-fun lookAheadValid_pre_4.40.20 () Int) +(declare-fun refEQ (Int Int) Int) +(declare-fun EC_loopold () Int) +(declare-fun EC_157.5 () Int) +(declare-fun remainingNodes_pre_48.26 () Int) +(declare-fun EC_156.1_0_158.5_0_160.18_160.18 () Int) +(declare-fun subtree_192.1_0_193.5 () Int) +(declare-fun is (Int Int) Int) +(declare-fun i_loopold_156.1_0_158.14 () Int) +(declare-fun integralEQ (Int Int) Int) +(declare-fun RES_87.8_0_89.24_89.24 () Int) +(declare-fun boolNE (Int Int) Bool) +(declare-fun EC_134.1_1_134.36_134.36 () Int) +(declare-fun RES_134.1_1_134.36_134.36 () Int) +(declare-fun T_java.io.FilterOutputStream () Int) +(declare-fun remainingNodes_48.26 () Int) +(declare-fun tmp0_new_Tree___130.25 () Int) +(declare-fun isNewArray (Int) Int) +(declare-fun L_192.1 () Int) +(declare-fun elems_pre () Int) +(declare-fun T_63.27 () Int) +(declare-fun intShiftL (Int Int) Int) +(declare-fun nonnullelements (Int Int) Bool) +(declare-fun multiply (Int Int) Int) +(declare-fun integralGE (Int Int) Int) +(declare-fun lookAhead_pre_4.43.19 () Int) +(declare-fun T_short () Int) +(declare-fun EC_67.21_67.21 () Int) +(declare-fun alloc_pre () Int) +(declare-fun integralGT (Int Int) Int) +(declare-fun EC () Int) +(declare-fun boolAnd (Int Int) Bool) +(declare-fun EC_156.1_0_158.5_0_159.11_159.11 () Int) +(declare-fun EC_1_ () Int) +(declare-fun EC_192.1_0_194.32_194.32 () Int) +(declare-fun RES_192.1_0_194.32_194.32 () Int) +(declare-fun arrayShapeOne (Int) Int) +(declare-fun T_double () Int) +(declare-fun out_16.83.49 () Int) +(declare-fun owner_6.35.28 () Int) +(declare-fun longShiftL (Int Int) Int) +(declare-fun list_pre_210.13 () Int) +(declare-fun T_java.io.Serializable () Int) +(declare-fun boolOr (Int Int) Bool) +(declare-fun L_134.1 () Int) +(declare-fun int_4294967295 () Int) +(declare-fun modulo (Int Int) Int) +(declare-fun EC_87.8_0_93.28_93.28 () Int) +(declare-fun EC_2_ () Int) +(declare-fun EC_130.35 () Int) +(declare-fun elems_134.1_0 () Int) +(declare-fun T_120.50 () Int) +(declare-fun returnsNull_pre_5.79.29 () Int) +(declare-fun EC_152.6 () Int) +(declare-fun EC_87.8_0_95.46_95.46 () Int) +(declare-fun EC_182.16 () Int) +(declare-fun after_95.46_87.8_0_95.46_5.89.17 () Int) +(declare-fun null () Int) +(declare-fun args_181.36 () Int) +(declare-fun EC_152.6_1_ () Int) +(declare-fun T_java.lang.String () Int) +(declare-fun asField (Int Int) Int) +(declare-fun a_150.36 () Int) +(declare-fun EC_68.21_68.21 () Int) +(declare-fun T_java.io.File () Int) +(declare-fun after_68.21_68.21 () Int) +(declare-fun boolImplies (Int Int) Bool) +(declare-fun sorted_157.13_1_ () Int) +(declare-fun integralLE (Int Int) Int) +(declare-fun RES_1_ () Int) +(declare-fun tmp0_remainingNodes_69.9 () Int) +(declare-fun elems_156.1_0_158.5_0 () Int) +(declare-fun integralLT (Int Int) Int) +(declare-fun this_93.28_87.8_0_93.28 () Int) +(declare-fun T_java.util.Enumeration () Int) +(declare-fun vAllocTime (Int) Int) +(declare-fun EC_192.1_0_193.28_193.28 () Int) +(declare-fun sorted_157.13_2_ () Int) +(declare-fun this_89.24_87.8_0_89.24 () Int) +(declare-fun T_java.lang.Cloneable () Int) +(declare-fun RES_192.1_0_193.28_193.28 () Int) +(declare-fun RES_2_ () Int) +(declare-fun boolNot (Int) Bool) +(declare-fun refNE (Int Int) Int) +(declare-fun integralXor (Int Int) Int) +(declare-fun classDown (Int Int) Int) +(declare-fun EC_loopold_156.1_0 () Int) +(declare-fun sorted_loopold_156.1_0_157.13 () Int) +(declare-fun this_90.24_87.8_0_90.24 () Int) +(declare-fun integralNE (Int Int) Int) +(declare-fun T_java.io.PrintStream () Int) +(declare-fun EC_87.8_0_90.24_90.24 () Int) +(declare-fun arrayParent (Int) Int) +(declare-fun elemtype (Int) Int) +(declare-fun fClosedTime (Int) Int) +(declare-fun alloc_1_ () Int) +(declare-fun EC_192.1_0_192.45_192.45 () Int) +(declare-fun array (Int) Int) +(declare-fun RES_192.1_0_192.45_192.45 () Int) +(declare-fun LS () Int) +(declare-fun remainingChildren_67.1 () Int) +(declare-fun ecReturn () Int) +(declare-fun isAllocated (Int Int) Bool) +(declare-fun alloc_2_ () Int) +(declare-fun elems () Int) +(declare-fun subtypes (Int Int) Bool) +(declare-fun T_javafe.filespace.EmptyEnum () Int) +(declare-fun EC_182.16_1_ () Int) +(declare-fun EC_121.33_121.33 () Int) +(assert (subtypes T_java.io.OutputStream T_java.lang.Object)) +(assert (= T_java.io.OutputStream (asChild T_java.io.OutputStream T_java.lang.Object))) +(assert (subtypes T_java.io.FilterOutputStream T_java.io.OutputStream)) +(assert (= T_java.io.FilterOutputStream (asChild T_java.io.FilterOutputStream T_java.io.OutputStream))) +(assert (subtypes T_javafe.filespace.TreeWalker T_javafe.filespace.LookAheadEnum)) +(assert (= T_javafe.filespace.TreeWalker (asChild T_javafe.filespace.TreeWalker T_javafe.filespace.LookAheadEnum))) +(assert (forall ((?t Int)) (! (= (subtypes ?t T_javafe.filespace.TreeWalker) (= ?t T_javafe.filespace.TreeWalker)) :pattern ((subtypes ?t T_javafe.filespace.TreeWalker)) ))) +(assert (subtypes T_javafe.filespace.FileTree T_javafe.filespace.PreloadedTree)) +(assert (= T_javafe.filespace.FileTree (asChild T_javafe.filespace.FileTree T_javafe.filespace.PreloadedTree))) +(assert (subtypes T_javafe.filespace.LookAheadEnum T_java.lang.Object)) +(assert (= T_javafe.filespace.LookAheadEnum (asChild T_javafe.filespace.LookAheadEnum T_java.lang.Object))) +(assert (subtypes T_javafe.filespace.LookAheadEnum T_java.util.Enumeration)) +(assert (subtypes T_javafe.filespace.TreeWalker_ArrayEnum T_javafe.filespace.LookAheadEnum)) +(assert (= T_javafe.filespace.TreeWalker_ArrayEnum (asChild T_javafe.filespace.TreeWalker_ArrayEnum T_javafe.filespace.LookAheadEnum))) +(assert (subtypes T_javafe.filespace.HashTree T_javafe.filespace.Tree)) +(assert (= T_javafe.filespace.HashTree (asChild T_javafe.filespace.HashTree T_javafe.filespace.Tree))) +(assert (subtypes T_java.lang.System T_java.lang.Object)) +(assert (= T_java.lang.System (asChild T_java.lang.System T_java.lang.Object))) +(assert (forall ((?t Int)) (! (= (subtypes ?t T_java.lang.System) (= ?t T_java.lang.System)) :pattern ((subtypes ?t T_java.lang.System)) ))) +(assert (subtypes T_java.util.EscjavaKeyValue T_java.lang.Object)) +(assert (subtypes T_java.util.Properties T_java.util.Hashtable)) +(assert (= T_java.util.Properties (asChild T_java.util.Properties T_java.util.Hashtable))) +(assert (subtypes T_javafe.filespace.Tree T_java.lang.Object)) +(assert (= T_javafe.filespace.Tree (asChild T_javafe.filespace.Tree T_java.lang.Object))) +(assert (subtypes T_java.lang.String T_java.lang.Object)) +(assert (= T_java.lang.String (asChild T_java.lang.String T_java.lang.Object))) +(assert (forall ((?t Int)) (! (= (subtypes ?t T_java.lang.String) (= ?t T_java.lang.String)) :pattern ((subtypes ?t T_java.lang.String)) ))) +(assert (subtypes T_java.lang.String T_java.io.Serializable)) +(assert (subtypes T_java.lang.String T_java.lang.Comparable)) +(assert (subtypes T_java.util.Enumeration T_java.lang.Object)) +(assert (subtypes T_java.lang.Comparable T_java.lang.Object)) +(assert (subtypes T_java.util.Map T_java.lang.Object)) +(assert (subtypes T_java.util.Map T_java.util.EscjavaKeyValue)) +(assert (subtypes T_java.util.Dictionary T_java.lang.Object)) +(assert (= T_java.util.Dictionary (asChild T_java.util.Dictionary T_java.lang.Object))) +(assert (subtypes T_java.util.Dictionary T_java.util.EscjavaKeyValue)) +(assert (subtypes T_java.io.Serializable T_java.lang.Object)) +(assert (subtypes T_java.io.PrintStream T_java.io.FilterOutputStream)) +(assert (= T_java.io.PrintStream (asChild T_java.io.PrintStream T_java.io.FilterOutputStream))) +(assert (subtypes T_javafe.filespace.PreloadedTree T_javafe.filespace.HashTree)) +(assert (= T_javafe.filespace.PreloadedTree (asChild T_javafe.filespace.PreloadedTree T_javafe.filespace.HashTree))) +(assert (subtypes T_java.util.Hashtable T_java.util.Dictionary)) +(assert (= T_java.util.Hashtable (asChild T_java.util.Hashtable T_java.util.Dictionary))) +(assert (subtypes T_java.util.Hashtable T_java.util.Map)) +(assert (subtypes T_java.util.Hashtable T_java.lang.Cloneable)) +(assert (subtypes T_java.util.Hashtable T_java.io.Serializable)) +(assert (subtypes T_java.lang.Cloneable T_java.lang.Object)) +(assert (subtypes T_javafe.filespace.EmptyEnum T_java.lang.Object)) +(assert (= T_javafe.filespace.EmptyEnum (asChild T_javafe.filespace.EmptyEnum T_java.lang.Object))) +(assert (subtypes T_javafe.filespace.EmptyEnum T_java.util.Enumeration)) +(assert (subtypes T_java.io.File T_java.lang.Object)) +(assert (= T_java.io.File (asChild T_java.io.File T_java.lang.Object))) +(assert (subtypes T_java.io.File T_java.io.Serializable)) +(assert (subtypes T_java.io.File T_java.lang.Comparable)) +(assert (distinct arrayType T_boolean T_char T_byte T_short T_int T_long T_float T_double T_.TYPE T_java.io.OutputStream T_java.io.FilterOutputStream T_javafe.filespace.TreeWalker T_javafe.filespace.FileTree T_javafe.filespace.LookAheadEnum T_javafe.filespace.TreeWalker_ArrayEnum T_javafe.filespace.HashTree T_java.lang.System T_java.util.EscjavaKeyValue T_java.util.Properties T_javafe.filespace.Tree T_java.lang.String T_java.util.Enumeration T_java.lang.Comparable T_java.util.Map T_java.util.Dictionary T_java.io.Serializable T_java.io.PrintStream T_javafe.filespace.PreloadedTree T_java.util.Hashtable T_java.lang.Cloneable T_javafe.filespace.EmptyEnum T_java.io.File T_java.lang.Object)) +(assert (= Smt.true (is out_16.83.49 T_java.io.PrintStream))) +(assert (forall ((?n Int)) (! (=> (and (<= 0 ?n) (< ?n 63)) (<= 1 (longShiftL 1 ?n))) :pattern ((longShiftL 1 ?n)) ))) +(assert (forall ((?n Int)) (! (=> (and (<= 0 ?n) (< ?n 31)) (<= 1 (intShiftL 1 ?n))) :pattern ((intShiftL 1 ?n)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (and (<= 0 ?x) (<= 0 ?y)) (<= 0 (integralXor ?x ?y))) :pattern ((integralXor ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (integralDiv ?x ?y))) (=> (and (<= 0 ?x) (< 0 ?y)) (and (<= 0 ?v_0) (<= ?v_0 ?x)))) :pattern ((integralDiv ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (integralOr ?x ?y))) (=> (and (<= 0 ?x) (<= 0 ?y)) (and (<= ?x ?v_0) (<= ?y ?v_0)))) :pattern ((integralOr ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (<= 0 ?y) (<= (integralAnd ?x ?y) ?y)) :pattern ((integralAnd ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (<= 0 ?x) (<= (integralAnd ?x ?y) ?x)) :pattern ((integralAnd ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (=> (or (<= 0 ?x) (<= 0 ?y)) (<= 0 (integralAnd ?x ?y))) :pattern ((integralAnd ?x ?y)) ))) +(assert (forall ((?t Int)) (! (let ((?v_0 (classLiteral ?t))) (and (not (= ?v_0 null)) (= Smt.true (is ?v_0 T_java.lang.Class)) (isAllocated ?v_0 alloc))) :pattern ((classLiteral ?t)) ))) +(assert (forall ((?x Int) (?e Int)) (= (nonnullelements ?x ?e) (and (not (= ?x null)) (forall ((?i Int)) (=> (and (<= 0 ?i) (< ?i (arrayLength ?x))) (not (= (select1 (select1 ?e ?x) ?i) null)))))))) +(assert (forall ((?b Int) (?x Int) (?y Int)) (! (=> (not (= ?b Smt.true)) (= (termConditional ?b ?x ?y) ?y)) :pattern ((termConditional ?b ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (termConditional Smt.true ?x ?y) ?x) :pattern ((termConditional Smt.true ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (refNE ?x ?y) Smt.true) (not (= ?x ?y))) :pattern ((refNE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (refEQ ?x ?y) Smt.true) (= ?x ?y)) :pattern ((refEQ ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralNE ?x ?y) Smt.true) (not (= ?x ?y))) :pattern ((integralNE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralLT ?x ?y) Smt.true) (< ?x ?y)) :pattern ((integralLT ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralLE ?x ?y) Smt.true) (<= ?x ?y)) :pattern ((integralLE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralGT ?x ?y) Smt.true) (> ?x ?y)) :pattern ((integralGT ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralGE ?x ?y) Smt.true) (>= ?x ?y)) :pattern ((integralGE ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (let ((?v_0 (stringCat ?x ?y))) (and (not (= ?v_0 null)) (subtypes (typeof ?v_0) T_java.lang.String))) :pattern ((stringCat ?x ?y)) ))) +(assert (forall ((?x Int) (?y Int)) (! (= (= (integralEQ ?x ?y) Smt.true) (= ?x ?y)) :pattern ((integralEQ ?x ?y)) ))) +(assert (forall ((?a Int) (?b Int)) (= (boolOr ?a ?b) (or (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?a Int)) (= (boolNot ?a) (not (= ?a Smt.true))))) +(assert (forall ((?a Int) (?b Int)) (= (boolNE ?a ?b) (not (= (= ?a Smt.true) (= ?b Smt.true)))))) +(assert (forall ((?a Int) (?b Int)) (= (boolImplies ?a ?b) (=> (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?a Int) (?b Int)) (= (boolEq ?a ?b) (= (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?a Int) (?b Int)) (= (boolAnd ?a ?b) (and (= ?a Smt.true) (= ?b Smt.true))))) +(assert (forall ((?x Int) (?y Int)) (let ((?v_0 (multiply ?x ?y))) (= (multiply (integralDiv ?v_0 ?y) ?y) ?v_0)))) +(assert (forall ((?i Int) (?j Int)) (= (integralMod (+ ?j ?i) ?j) (integralMod ?i ?j)))) +(assert (forall ((?i Int) (?j Int)) (= (integralMod (+ ?i ?j) ?j) (integralMod ?i ?j)))) +(assert (forall ((?i Int) (?j Int)) (! (let ((?v_0 (integralMod ?i ?j))) (=> (< ?j 0) (and (< ?j ?v_0) (<= ?v_0 0)))) :pattern ((integralMod ?i ?j)) ))) +(assert (forall ((?i Int) (?j Int)) (! (let ((?v_0 (integralMod ?i ?j))) (=> (< 0 ?j) (and (<= 0 ?v_0) (< ?v_0 ?j)))) :pattern ((integralMod ?i ?j)) ))) +(assert (forall ((?i Int) (?j Int)) (! (= (+ (multiply (integralDiv ?i ?j) ?j) (integralMod ?i ?j)) ?i) :pattern ((integralMod ?i ?j)) :pattern ((integralDiv ?i ?j)) ))) +(assert (forall ((?s Int)) (! (=> (= Smt.true (isNewArray ?s)) (subtypes (typeof ?s) arrayType)) :pattern ((isNewArray ?s)) ))) +(assert (forall ((?t Int)) (! (subtypes (array ?t) arrayType) :pattern ((array ?t)) ))) +(assert (= arrayType (asChild arrayType T_java.lang.Object))) +(assert (forall ((?a Int) (?a0 Int) (?b0 Int) (?e Int) (?n Int) (?T Int) (?v Int)) (! (= (arrayFresh ?a ?a0 ?b0 ?e (arrayShapeOne ?n) ?T ?v) (and (<= ?a0 (vAllocTime ?a)) (isAllocated ?a ?b0) (not (= ?a null)) (= (typeof ?a) ?T) (= (arrayLength ?a) ?n) (forall ((?i Int)) (! (= (select1 (select1 ?e ?a) ?i) ?v) :pattern ((select1 (select1 ?e ?a) ?i)) )))) :pattern ((arrayFresh ?a ?a0 ?b0 ?e (arrayShapeOne ?n) ?T ?v)) ))) +(assert (forall ((?a Int) (?a0 Int) (?b0 Int) (?e Int) (?n Int) (?s Int) (?T Int) (?v Int)) (! (= (arrayFresh ?a ?a0 ?b0 ?e (arrayShapeMore ?n ?s) ?T ?v) (and (<= ?a0 (vAllocTime ?a)) (isAllocated ?a ?b0) (not (= ?a null)) (= (typeof ?a) ?T) (= (arrayLength ?a) ?n) (forall ((?i Int)) (! (let ((?v_0 (select1 (select1 ?e ?a) ?i))) (and (arrayFresh ?v_0 ?a0 ?b0 ?e ?s (elemtype ?T) ?v) (= (arrayParent ?v_0) ?a) (= (arrayPosition ?v_0) ?i))) :pattern ((select1 (select1 ?e ?a) ?i)) )))) :pattern ((arrayFresh ?a ?a0 ?b0 ?e (arrayShapeMore ?n ?s) ?T ?v)) ))) +(assert (forall ((?a Int)) (! (let ((?v_0 (arrayLength ?a))) (and (<= 0 ?v_0) (= Smt.true (is ?v_0 T_int)))) :pattern ((arrayLength ?a)) ))) +(assert (forall ((?x Int)) (! (=> (subtypes (typeof ?x) T_java.lang.Object) (lockLE null ?x)) :pattern ((lockLE null ?x)) :pattern ((lockLT null ?x)) :pattern ((lockLE ?x null)) :pattern ((lockLT ?x null)) ))) +(assert (forall ((?S Int) (?mu Int)) (let ((?v_0 (asLockSet ?S))) (=> (= (select1 ?v_0 ?mu) Smt.true) (lockLE ?mu (max ?v_0)))))) +(assert (forall ((?x Int) (?y Int)) (= (lockLT ?x ?y) (< ?x ?y)))) +(assert (forall ((?x Int) (?y Int)) (= (lockLE ?x ?y) (<= ?x ?y)))) +(assert (forall ((?S Int)) (! (= (select1 (asLockSet ?S) null) Smt.true) :pattern ((asLockSet ?S)) ))) +(assert (forall ((?S Int)) (let ((?v_0 (asLockSet ?S))) (= (select1 ?v_0 (max ?v_0)) Smt.true)))) +(assert (forall ((?a Int) (?e Int) (?i Int) (?a0 Int)) (! (=> (and (< (eClosedTime ?e) ?a0) (isAllocated ?a ?a0)) (isAllocated (select1 (select1 ?e ?a) ?i) ?a0)) :pattern ((isAllocated (select1 (select1 ?e ?a) ?i) ?a0)) ))) +(assert (forall ((?x Int) (?f Int) (?a0 Int)) (! (=> (and (< (fClosedTime ?f) ?a0) (isAllocated ?x ?a0)) (isAllocated (select1 ?f ?x) ?a0)) :pattern ((isAllocated (select1 ?f ?x) ?a0)) ))) +(assert (forall ((?x Int) (?a0 Int)) (= (isAllocated ?x ?a0) (< (vAllocTime ?x) ?a0)))) +(assert (forall ((?e Int) (?a Int) (?i Int)) (! (= Smt.true (is (select1 (select1 (asElems ?e) ?a) ?i) (elemtype (typeof ?a)))) :pattern ((select1 (select1 (asElems ?e) ?a) ?i)) ))) +(assert (forall ((?f Int) (?t Int) (?x Int)) (! (= Smt.true (is (select1 (asField ?f ?t) ?x) ?t)) :pattern ((select1 (asField ?f ?t) ?x)) ))) +(assert (forall ((?x Int) (?t Int)) (! (=> (subtypes ?t T_java.lang.Object) (= (= Smt.true (is ?x ?t)) (or (= ?x null) (subtypes (typeof ?x) ?t)))) :pattern ((subtypes ?t T_java.lang.Object) (is ?x ?t)) ))) +(assert (< intLast longLast)) +(assert (< 1000000 intLast)) +(assert (< intFirst (- 1000000))) +(assert (< longFirst intFirst)) +(assert (forall ((?x Int)) (! (= (= Smt.true (is ?x T_long)) (and (<= longFirst ?x) (<= ?x longLast))) :pattern ((is ?x T_long)) ))) +(assert (forall ((?x Int)) (! (= (= Smt.true (is ?x T_int)) (and (<= intFirst ?x) (<= ?x intLast))) :pattern ((is ?x T_int)) ))) +(assert (forall ((?x Int)) (= (= Smt.true (is ?x T_short)) (and (<= (- 32768) ?x) (<= ?x 32767))))) +(assert (forall ((?x Int)) (= (= Smt.true (is ?x T_byte)) (and (<= (- 128) ?x) (<= ?x 127))))) +(assert (forall ((?x Int)) (! (= (= Smt.true (is ?x T_char)) (and (<= 0 ?x) (<= ?x 65535))) :pattern ((is ?x T_char)) ))) +(assert (distinct bool_false Smt.true)) +(assert (forall ((?x Int) (?t Int)) (! (=> (= Smt.true (is ?x ?t)) (= (cast ?x ?t) ?x)) :pattern ((cast ?x ?t)) ))) +(assert (forall ((?x Int) (?t Int)) (! (= Smt.true (is (cast ?x ?t) ?t)) :pattern ((cast ?x ?t)) ))) +(assert (forall ((?t0 Int) (?t1 Int)) (! (let ((?v_0 (elemtype ?t0))) (= (subtypes ?t0 (array ?t1)) (and (= ?t0 (array ?v_0)) (subtypes ?v_0 ?t1)))) :pattern ((subtypes ?t0 (array ?t1))) ))) +(assert (forall ((?t Int)) (! (= (elemtype (array ?t)) ?t) :pattern ((elemtype (array ?t))) ))) +(assert (forall ((?t Int)) (! (subtypes (array ?t) T_java.lang.Cloneable) :pattern ((array ?t)) ))) +(assert (subtypes T_java.lang.Cloneable T_java.lang.Object)) +(assert (forall ((?t0 Int) (?t1 Int) (?t2 Int)) (let ((?v_0 (asChild ?t1 ?t2))) (=> (subtypes ?t0 ?v_0) (= (classDown ?t2 ?t0) ?v_0))))) +(assert (forall ((?t Int)) (! (=> (subtypes T_double ?t) (= ?t T_double)) :pattern ((subtypes T_double ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_float ?t) (= ?t T_float)) :pattern ((subtypes T_float ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_long ?t) (= ?t T_long)) :pattern ((subtypes T_long ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_int ?t) (= ?t T_int)) :pattern ((subtypes T_int ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_short ?t) (= ?t T_short)) :pattern ((subtypes T_short ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_byte ?t) (= ?t T_byte)) :pattern ((subtypes T_byte ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_char ?t) (= ?t T_char)) :pattern ((subtypes T_char ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes T_boolean ?t) (= ?t T_boolean)) :pattern ((subtypes T_boolean ?t)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_double) (= ?t T_double)) :pattern ((subtypes ?t T_double)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_float) (= ?t T_float)) :pattern ((subtypes ?t T_float)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_long) (= ?t T_long)) :pattern ((subtypes ?t T_long)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_int) (= ?t T_int)) :pattern ((subtypes ?t T_int)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_short) (= ?t T_short)) :pattern ((subtypes ?t T_short)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_byte) (= ?t T_byte)) :pattern ((subtypes ?t T_byte)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_char) (= ?t T_char)) :pattern ((subtypes ?t T_char)) ))) +(assert (forall ((?t Int)) (! (=> (subtypes ?t T_boolean) (= ?t T_boolean)) :pattern ((subtypes ?t T_boolean)) ))) +(assert (forall ((?t0 Int) (?t1 Int)) (! (=> (and (subtypes ?t0 ?t1) (subtypes ?t1 ?t0)) (= ?t0 ?t1)) :pattern ((subtypes ?t0 ?t1) (subtypes ?t1 ?t0)) ))) +(assert (forall ((?t0 Int) (?t1 Int) (?t2 Int)) (! (=> (and (subtypes ?t0 ?t1) (subtypes ?t1 ?t2)) (subtypes ?t0 ?t2)) :pattern ((subtypes ?t0 ?t1) (subtypes ?t1 ?t2)) ))) +(assert (subtypes T_java.lang.Object T_java.lang.Object)) +(assert (forall ((?t Int)) (! (subtypes ?t ?t) :pattern ((subtypes ?t ?t)) ))) +(assert (forall ((?m Int) (?i Int) (?j Int) (?x Int)) (=> (not (= ?i ?j)) (= (select1 (store1 ?m ?i ?x) ?j) (select1 ?m ?j))))) +(assert (forall ((?m Int) (?i Int) (?x Int)) (= (select1 (store1 ?m ?i ?x) ?i) ?x))) +(assert (let ((?v_0 (not (= args_181.36 null)))) (let ((?v_1 (not ?v_0)) (?v_3 (arrayLength args_181.36))) (let ((?v_61 (not (= ?v_3 1)))) (let ((?v_29 (not ?v_61)) (?v_8 (= Smt.true Smt.true)) (?v_2 (<= 0 0)) (?v_4 (< 0 ?v_3)) (?v_30 (= treeName_186.1 (select1 (select1 elems args_181.36) 0))) (?v_5 (not (= treeName_186.1 null))) (?v_31 (< alloc after_189.25_189.25)) (?v_6 (not (= RES_189.25_189.25 null))) (?v_32 (not (isAllocated RES_189.25_189.25 alloc))) (?v_33 (= Smt.true (is RES_189.25_189.25 T_java.io.File))) (?v_34 (isAllocated RES_189.25_189.25 after_189.25_189.25)) (?v_35 (= EC_189.25_189.25 ecReturn)) (?v_36 (= (select1 owner_6.35.28 RES_189.25_189.25) null)) (?v_37 (= (typeof RES_189.25_189.25) T_java.io.File)) (?v_38 (< after_189.25_189.25 after_189.12_189.12)) (?v_7 (not (= RES_189.12_189.12 null))) (?v_39 (not (isAllocated RES_189.12_189.12 after_189.25_189.25))) (?v_40 (= Smt.true (is RES_189.12_189.12 T_javafe.filespace.FileTree))) (?v_41 (isAllocated RES_189.12_189.12 after_189.12_189.12)) (?v_42 (= EC_189.12_189.12 ecReturn)) (?v_43 (= (select1 owner_6.35.28 RES_189.12_189.12) null)) (?v_44 (= (typeof RES_189.12_189.12) T_javafe.filespace.FileTree)) (?v_45 (< after_189.12_189.12 after_192.22_192.22)) (?v_9 (not (= RES_192.22_192.22 null))) (?v_46 (not (isAllocated RES_192.22_192.22 after_189.12_189.12))) (?v_47 (= Smt.true (is RES_192.22_192.22 T_javafe.filespace.TreeWalker))) (?v_48 (isAllocated RES_192.22_192.22 after_192.22_192.22)) (?v_49 (= EC_192.22_192.22 ecReturn)) (?v_50 (= (select1 owner_6.35.28 RES_192.22_192.22) null)) (?v_51 (= (typeof RES_192.22_192.22) T_javafe.filespace.TreeWalker)) (?v_52 (= EC_192.22_192.22 EC_loopold)) (?v_53 (= moreElements_5.58.29 moreElements_loopold_5.58.29))) (let ((?v_12 (not ?v_9)) (?v_17 (= Smt.true (is RES_192.1_0_192.45_192.45 T_boolean))) (?v_10 (= EC_192.1_0_192.45_192.45 ecReturn)) (?v_11 (= Smt.true RES_192.1_0_192.45_192.45)) (?v_13 (= Smt.true (select1 moreElements_5.58.29 RES_192.22_192.22)))) (let ((?v_18 (=> ?v_10 (= ?v_11 ?v_13))) (?v_19 (= moreElements_192.1_0_193.28_5.89.17 (store1 moreElements_5.58.29 RES_192.22_192.22 after_193.28_192.1_0_193.28_5.89.17))) (?v_20 (= moreElements_192.1_0_193.28_5.89.17 (asField moreElements_192.1_0_193.28_5.89.17 T_boolean))) (?v_21 (= Smt.true (is RES_192.1_0_193.28_193.28 T_java.lang.Object))) (?v_22 (isAllocated RES_192.1_0_193.28_193.28 after_192.22_192.22)) (?v_14 (= EC_192.1_0_193.28_193.28 ecReturn)) (?v_15 (= RES_192.1_0_193.28_193.28 null))) (let ((?v_23 (=> ?v_14 (or (subtypes (typeof RES_192.1_0_193.28_193.28) (select1 elementType_5.74.27 RES_192.22_192.22)) ?v_15))) (?v_24 (=> (and ?v_14 (not (= Smt.true (select1 returnsNull_5.79.29 RES_192.22_192.22)))) (not ?v_15))) (?v_25 (forall ((?brokenObj_11_ Int)) (let ((?v_65 (= Smt.true (select1 lookAheadValid_4.40.20 ?brokenObj_11_))) (?v_66 (not (= (select1 lookAhead_4.43.19 ?brokenObj_11_) null)))) (=> (and (= Smt.true (is ?brokenObj_11_ T_javafe.filespace.LookAheadEnum)) (not (= ?brokenObj_11_ null)) (=> ?v_65 (= (= Smt.true (select1 moreElements_5.58.29 ?brokenObj_11_)) ?v_66)) ?v_65) (= (= Smt.true (select1 moreElements_192.1_0_193.28_5.89.17 ?brokenObj_11_)) ?v_66))))) (?v_16 (= Smt.true (is RES_192.1_0_193.28_193.28 T_javafe.filespace.Tree))) (?v_26 (= subtree_192.1_0_193.5 (cast RES_192.1_0_193.28_193.28 T_javafe.filespace.Tree))) (?v_27 (not (= subtree_192.1_0_193.5 null))) (?v_54 (= Smt.true (is RES_192.1_0_194.32_194.32 T_java.lang.String))) (?v_55 (isAllocated RES_192.1_0_194.32_194.32 after_192.22_192.22)) (?v_28 (= EC_192.1_0_194.32_194.32 ecReturn))) (let ((?v_56 (=> ?v_28 (not (= RES_192.1_0_194.32_194.32 null)))) (?v_57 (= arg0_194.16_192.1_0_194.16_17.. (stringCat RES_192.1_0_194.32_194.32 S_194.56))) (?v_58 (= EC_192.1_0_194.16_194.16 ecReturn)) (?v_59 (= EC_192.1_1_192.45_192.45 ecReturn)) (?v_60 (= Smt.true RES_192.1_1_192.45_192.45))) (let ((?v_62 (or (and ?v_8 ?v_9 ?v_17 ?v_10 ?v_18 (not ?v_11)) (and ?v_8 ?v_9 ?v_17 ?v_10 ?v_18 ?v_11 ?v_9 ?v_13 ?v_19 ?v_20 ?v_21 ?v_22 ?v_14 ?v_23 ?v_24 ?v_25 ?v_16 ?v_26 ?v_27 ?v_54 ?v_55 ?v_28 ?v_56 ?v_57 ?v_58 ?v_8 ?v_9 (= Smt.true (is RES_192.1_1_192.45_192.45 T_boolean)) ?v_59 (=> ?v_59 (= ?v_60 (= Smt.true (select1 moreElements_192.1_0_193.28_5.89.17 RES_192.22_192.22)))) (not ?v_60)))) (?v_63 (= L_192.1 L_192.1)) (?v_64 (= EC_182.16 ecReturn))) (not (=> (and (distinct ecReturn L_192.1) (not (= S_194.56 null)) (= (typeof S_194.56) T_java.lang.String)) (=> (and (= elementType_pre_5.74.27 elementType_5.74.27) (= elementType_5.74.27 (asField elementType_5.74.27 T_.TYPE)) (= owner_pre_6.35.28 owner_6.35.28) (= owner_6.35.28 (asField owner_6.35.28 T_java.lang.Object)) (< (fClosedTime owner_6.35.28) alloc) (= list_pre_210.13 list_210.13) (= list_210.13 (asField list_210.13 (array T_java.lang.Object))) (< (fClosedTime list_210.13) alloc) (= lookAheadValid_pre_4.40.20 lookAheadValid_4.40.20) (= lookAheadValid_4.40.20 (asField lookAheadValid_4.40.20 T_boolean)) (= remainingNodes_pre_48.26 remainingNodes_48.26) (= remainingNodes_48.26 (asField remainingNodes_48.26 T_java.util.Enumeration)) (< (fClosedTime remainingNodes_48.26) alloc) (= out_pre_16.83.49 out_16.83.49) (= Smt.true (is out_16.83.49 T_java.io.PrintStream)) (isAllocated out_16.83.49 alloc) (not (= out_16.83.49 null)) (= lookAhead_pre_4.43.19 lookAhead_4.43.19) (= lookAhead_4.43.19 (asField lookAhead_4.43.19 T_java.lang.Object)) (< (fClosedTime lookAhead_4.43.19) alloc) (= returnsNull_pre_5.79.29 returnsNull_5.79.29) (= returnsNull_5.79.29 (asField returnsNull_5.79.29 T_boolean)) (= moreElements_pre_5.58.29 moreElements_5.58.29) (= moreElements_5.58.29 (asField moreElements_5.58.29 T_boolean)) (= remainingChildren_pre_39.26 remainingChildren_39.26) (= remainingChildren_39.26 (asField remainingChildren_39.26 T_java.util.Enumeration)) (< (fClosedTime remainingChildren_39.26) alloc) (= elems_pre elems) (= elems (asElems elems)) (< (eClosedTime elems) alloc) (= LS (asLockSet LS)) (= alloc_pre alloc)) (not (and (= Smt.true (is args_181.36 (array T_java.lang.String))) (isAllocated args_181.36 alloc) (nonnullelements args_181.36 elems) (forall ((?brokenObj Int)) (=> (and (= Smt.true (is ?brokenObj T_javafe.filespace.TreeWalker)) (not (= ?brokenObj null))) (= (select1 elementType_5.74.27 (select1 remainingChildren_39.26 ?brokenObj)) T_javafe.filespace.Tree))) (forall ((?brokenObj_1_ Int)) (=> (and (= Smt.true (is ?brokenObj_1_ T_javafe.filespace.TreeWalker)) (not (= ?brokenObj_1_ null))) (not (= (select1 remainingChildren_39.26 ?brokenObj_1_) null)))) (forall ((?brokenObj_2_ Int)) (=> (and (= Smt.true (is ?brokenObj_2_ T_javafe.filespace.TreeWalker)) (not (= ?brokenObj_2_ null))) (not (= Smt.true (select1 returnsNull_5.79.29 ?brokenObj_2_))))) (forall ((?brokenObj_3_ Int)) (=> (and (= Smt.true (is ?brokenObj_3_ T_javafe.filespace.TreeWalker)) (not (= ?brokenObj_3_ null))) (= (select1 elementType_5.74.27 (select1 remainingNodes_48.26 ?brokenObj_3_)) T_javafe.filespace.Tree))) (forall ((?brokenObj_4_ Int)) (=> (and (= Smt.true (is ?brokenObj_4_ T_javafe.filespace.LookAheadEnum)) (not (= ?brokenObj_4_ null)) (= Smt.true (select1 lookAheadValid_4.40.20 ?brokenObj_4_))) (= (= Smt.true (select1 moreElements_5.58.29 ?brokenObj_4_)) (not (= (select1 lookAhead_4.43.19 ?brokenObj_4_) null))))) (forall ((?brokenObj_5_ Int)) (=> (and (= Smt.true (is ?brokenObj_5_ T_javafe.filespace.TreeWalker)) (not (= ?brokenObj_5_ null))) (not (= (select1 remainingNodes_48.26 ?brokenObj_5_) null)))) (forall ((?brokenObj_6_ Int)) (=> (and (= Smt.true (is ?brokenObj_6_ T_javafe.filespace.TreeWalker)) (not (= ?brokenObj_6_ null))) (not (= Smt.true (select1 returnsNull_5.79.29 (select1 remainingChildren_39.26 ?brokenObj_6_)))))) (forall ((?brokenObj_7_ Int)) (=> (and (= Smt.true (is ?brokenObj_7_ T_javafe.filespace.TreeWalker)) (not (= ?brokenObj_7_ null))) (= (select1 elementType_5.74.27 ?brokenObj_7_) T_javafe.filespace.Tree))) (forall ((?brokenObj_8_ Int)) (let ((?v_67 (select1 lookAhead_4.43.19 ?brokenObj_8_))) (=> (and (= Smt.true (is ?brokenObj_8_ T_javafe.filespace.LookAheadEnum)) (not (= ?brokenObj_8_ null))) (or (subtypes (typeof ?v_67) (select1 elementType_5.74.27 ?brokenObj_8_)) (= ?v_67 null))))) (forall ((?brokenObj_9_ Int)) (=> (and (= Smt.true (is ?brokenObj_9_ T_javafe.filespace.TreeWalker)) (not (= ?brokenObj_9_ null))) (not (= Smt.true (select1 returnsNull_5.79.29 (select1 remainingNodes_48.26 ?brokenObj_9_)))))) (forall ((?brokenObj_10_ Int)) (=> (and (= Smt.true (is ?brokenObj_10_ T_javafe.filespace.LookAheadEnum)) (not (= ?brokenObj_10_ null))) (not (= Smt.true (select1 returnsNull_5.79.29 ?brokenObj_10_))))) (or ?v_1 (and ?v_0 ?v_29 ?v_8 (or ?v_1 (and ?v_0 (or (not ?v_2) (and ?v_2 (or (not ?v_4) (and ?v_4 ?v_30 (or (not ?v_5) (and ?v_5 ?v_31 ?v_6 ?v_32 ?v_33 ?v_34 ?v_35 ?v_36 ?v_37 (or (not ?v_6) (and ?v_6 ?v_38 ?v_7 ?v_39 ?v_40 ?v_41 ?v_42 ?v_43 ?v_44 (or (not ?v_7) (and ?v_7 ?v_45 ?v_9 ?v_46 ?v_47 ?v_48 ?v_49 ?v_50 ?v_51 ?v_52 ?v_53 (or (and ?v_8 (or ?v_12 (and ?v_9 ?v_17 ?v_10 ?v_18 ?v_11 (or ?v_12 (and ?v_9 (or (not ?v_13) (and ?v_13 ?v_19 ?v_20 ?v_21 ?v_22 ?v_14 ?v_23 ?v_24 ?v_25 (or (not ?v_16) (and ?v_16 ?v_26 (not ?v_27)))))))))) (and ?v_8 ?v_9 ?v_17 ?v_10 ?v_18 ?v_11 ?v_9 ?v_13 ?v_19 ?v_20 ?v_21 ?v_22 ?v_14 ?v_23 ?v_24 ?v_25 ?v_16 ?v_26 ?v_27 ?v_54 ?v_55 ?v_28 ?v_56 ?v_57 ?v_58 ?v_8 ?v_12))))))))))))))) (and (or (and ?v_0 ?v_29 ?v_8 ?v_0 ?v_2 ?v_4 ?v_30 ?v_5 ?v_31 ?v_6 ?v_32 ?v_33 ?v_34 ?v_35 ?v_36 ?v_37 ?v_6 ?v_38 ?v_7 ?v_39 ?v_40 ?v_41 ?v_42 ?v_43 ?v_44 ?v_7 ?v_45 ?v_9 ?v_46 ?v_47 ?v_48 ?v_49 ?v_50 ?v_51 ?v_52 ?v_53 ?v_62 ?v_63 (= EC L_192.1) ?v_64) (and ?v_0 (or (and ?v_61 ?v_8 (= EC_183.16_183.16 ecReturn) ?v_8 (= EC_182.16_1_ ecReturn)) (and ?v_29 ?v_8 ?v_0 ?v_2 ?v_4 ?v_30 ?v_5 ?v_31 ?v_6 ?v_32 ?v_33 ?v_34 ?v_35 ?v_36 ?v_37 ?v_6 ?v_38 ?v_7 ?v_39 ?v_40 ?v_41 ?v_42 ?v_43 ?v_44 ?v_7 ?v_45 ?v_9 ?v_46 ?v_47 ?v_48 ?v_49 ?v_50 ?v_51 ?v_52 ?v_53 ?v_62 (not ?v_63) (= EC_182.16_1_ L_192.1))) (= EC_182.16 EC_182.16_1_))) (not ?v_64)))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/qcft-smtlib3dbc51.smt2 b/test/regress/regress1/quantifiers/qcft-smtlib3dbc51.smt2 new file mode 100644 index 000000000..6874c522e --- /dev/null +++ b/test/regress/regress1/quantifiers/qcft-smtlib3dbc51.smt2 @@ -0,0 +1,233 @@ +; COMMAND-LINE: --qcf-tconstraint +; EXPECT: unsat +(set-logic AUFLIRA) +(set-info :source |http://proval.lri.fr/why-benchmarks |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-sort Unit 0) +(declare-sort c_unique 0) +(declare-sort c_ssorted 0) +(declare-sort c_type 0) +(declare-sort c_Boolean 0) +(declare-fun c_sort (c_type c_unique) c_ssorted) +(declare-fun c_Boolean_true () c_Boolean) +(declare-fun c_Boolean_false () c_Boolean) +(assert (forall ((?b_22_1 c_Boolean)) (or (= c_Boolean_true ?b_22_1) (= c_Boolean_false ?b_22_1)))) +(assert (not (= c_Boolean_true c_Boolean_false))) +(declare-fun int2U (Int) c_unique) +(declare-fun ss2Int (c_ssorted) Int) +(declare-fun real2U (Real) c_unique) +(declare-fun ss2Real (c_ssorted) Real) +(declare-fun bool2U (c_Boolean) c_unique) +(declare-fun ss2Bool (c_ssorted) c_Boolean) +(declare-fun c_int () c_type) +(declare-fun c_bool () c_type) +(declare-fun c_real () c_type) +(declare-fun c_unit () c_type) +(declare-fun c_ref (c_unique) c_unique) +(assert (forall ((?t_21_2 c_type)) (forall ((?x_20_3 c_unique)) (forall ((?y_19_4 c_unique)) (=> (= (c_sort ?t_21_2 ?x_20_3) (c_sort ?t_21_2 ?y_19_4)) (= ?x_20_3 ?y_19_4)))))) +(assert (forall ((?x_18_5 Int)) (= (ss2Int (c_sort c_int (int2U ?x_18_5))) ?x_18_5))) +(assert (forall ((?x_17_6 Int)) (forall ((?y_16_7 Int)) (=> (= (int2U ?x_17_6) (int2U ?y_16_7)) (= ?x_17_6 ?y_16_7))))) +(assert (forall ((?x_15_8 Real)) (forall ((?y_14_9 Real)) (=> (= (real2U ?x_15_8) (real2U ?y_14_9)) (= ?x_15_8 ?y_14_9))))) +(assert (forall ((?x_13_10 c_Boolean)) (forall ((?y_12_11 c_Boolean)) (=> (= (bool2U ?x_13_10) (bool2U ?y_12_11)) (= ?x_13_10 ?y_12_11))))) +(assert (forall ((?x_11_12 c_ssorted)) (forall ((?y_10_13 c_ssorted)) (=> (= (ss2Int ?x_11_12) (ss2Int ?y_10_13)) (= ?x_11_12 ?y_10_13))))) +(assert (forall ((?x_9_14 c_ssorted)) (forall ((?y_8_15 c_ssorted)) (=> (= (ss2Real ?x_9_14) (ss2Real ?y_8_15)) (= ?x_9_14 ?y_8_15))))) +(assert (forall ((?x_7_16 c_ssorted)) (forall ((?y_6_17 c_ssorted)) (=> (= (ss2Bool ?x_7_16) (ss2Bool ?y_6_17)) (= ?x_7_16 ?y_6_17))))) +(assert (forall ((?x_5_18 Real)) (= (ss2Real (c_sort c_real (real2U ?x_5_18))) ?x_5_18))) +(assert (forall ((?x_4_19 c_Boolean)) (= (ss2Bool (c_sort c_bool (bool2U ?x_4_19))) ?x_4_19))) +(assert (forall ((?x_3_20 c_unique)) (= (int2U (ss2Int (c_sort c_int ?x_3_20))) ?x_3_20))) +(assert (forall ((?x_2_21 c_unique)) (= (real2U (ss2Real (c_sort c_real ?x_2_21))) ?x_2_21))) +(assert (forall ((?x_1_22 c_unique)) (= (bool2U (ss2Bool (c_sort c_bool ?x_1_22))) ?x_1_22))) +(declare-fun eq_int (Int Int) Bool) +(declare-fun neq_int (Int Int) Bool) +(declare-fun lt_int_bool (Int Int) c_Boolean) +(declare-fun le_int_bool (Int Int) c_Boolean) +(declare-fun gt_int_bool (Int Int) c_Boolean) +(declare-fun ge_int_bool (Int Int) c_Boolean) +(declare-fun eq_int_bool (Int Int) c_Boolean) +(declare-fun neq_int_bool (Int Int) c_Boolean) +(assert (forall ((?x_40_23 Int)) (forall ((?y_39_24 Int)) (= (= (lt_int_bool ?x_40_23 ?y_39_24) c_Boolean_true) (< ?x_40_23 ?y_39_24))))) +(assert (forall ((?x_42_25 Int)) (forall ((?y_41_26 Int)) (= (= (le_int_bool ?x_42_25 ?y_41_26) c_Boolean_true) (<= ?x_42_25 ?y_41_26))))) +(assert (forall ((?x_44_27 Int)) (forall ((?y_43_28 Int)) (= (= (gt_int_bool ?x_44_27 ?y_43_28) c_Boolean_true) (> ?x_44_27 ?y_43_28))))) +(assert (forall ((?x_46_29 Int)) (forall ((?y_45_30 Int)) (= (= (ge_int_bool ?x_46_29 ?y_45_30) c_Boolean_true) (>= ?x_46_29 ?y_45_30))))) +(assert (forall ((?x_48_31 Int)) (forall ((?y_47_32 Int)) (= (= (eq_int_bool ?x_48_31 ?y_47_32) c_Boolean_true) (= ?x_48_31 ?y_47_32))))) +(assert (forall ((?x_50_33 Int)) (forall ((?y_49_34 Int)) (= (= (neq_int_bool ?x_50_33 ?y_49_34) c_Boolean_true) (not (= ?x_50_33 ?y_49_34)))))) +(declare-fun add_real (Real Real) Real) +(declare-fun sub_real (Real Real) Real) +(declare-fun mul_real (Real Real) Real) +(declare-fun div_real (Real Real) Real) +(declare-fun pow_real (Real Real) Real) +(declare-fun neg_real (Real) Real) +(declare-fun abs_real (Real) Real) +(declare-fun sqrt_real (Real) Real) +(declare-fun real_of_int (Int) Real) +(declare-fun int_of_real (Real) Int) +(declare-fun lt_real (Real Real) Bool) +(declare-fun le_real (Real Real) Bool) +(declare-fun gt_real (Real Real) Bool) +(declare-fun ge_real (Real Real) Bool) +(declare-fun eq_real (Real Real) Bool) +(declare-fun neq_real (Real Real) Bool) +(declare-fun eq_bool (c_Boolean c_Boolean) Bool) +(declare-fun neq_bool (c_Boolean c_Boolean) Bool) +(declare-fun eq_unit (c_ssorted c_ssorted) Bool) +(declare-fun neq_unit (c_ssorted c_ssorted) Bool) +(declare-fun smtlib__ite (c_Boolean c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_1_76_35 c_type)) (forall ((?x_75_36 c_unique)) (forall ((?y_74_37 c_unique)) (= (smtlib__ite c_Boolean_true (c_sort ?t_1_76_35 ?x_75_36) (c_sort ?t_1_76_35 ?y_74_37)) ?x_75_36))))) +(assert (forall ((?t_2_79_38 c_type)) (forall ((?x_78_39 c_unique)) (forall ((?y_77_40 c_unique)) (= (smtlib__ite c_Boolean_false (c_sort ?t_2_79_38 ?x_78_39) (c_sort ?t_2_79_38 ?y_77_40)) ?y_77_40))))) +(declare-fun bw_compl (Int) Int) +(declare-fun bw_and (Int Int) Int) +(declare-fun bw_xor (Int Int) Int) +(declare-fun bw_or (Int Int) Int) +(declare-fun lsl (Int Int) Int) +(declare-fun lsr (Int Int) Int) +(declare-fun non_int (Int) Int) +(declare-fun type_pointer (c_type) c_type) +(declare-fun type_addr (c_type) c_type) +(declare-fun type_alloc_table () c_type) +(declare-fun block_length (c_ssorted c_ssorted) Int) +(declare-fun base_addr (c_ssorted) c_unique) +(declare-fun offset (c_ssorted) Int) +(declare-fun shift (c_ssorted Int) c_unique) +(declare-fun sub_pointer (c_ssorted c_ssorted) Int) +(declare-fun lt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_3_88_41 c_type)) (forall ((?p1_87_42 c_unique)) (forall ((?p2_86_43 c_unique)) (let ((?v_0 (type_pointer ?t_3_88_41))) (let ((?v_1 (c_sort ?v_0 ?p1_87_42)) (?v_2 (c_sort ?v_0 ?p2_86_43))) (= (lt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (< (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun le_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_4_91_44 c_type)) (forall ((?p1_90_45 c_unique)) (forall ((?p2_89_46 c_unique)) (let ((?v_0 (type_pointer ?t_4_91_44))) (let ((?v_1 (c_sort ?v_0 ?p1_90_45)) (?v_2 (c_sort ?v_0 ?p2_89_46))) (= (le_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (<= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun gt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_5_94_47 c_type)) (forall ((?p1_93_48 c_unique)) (forall ((?p2_92_49 c_unique)) (let ((?v_0 (type_pointer ?t_5_94_47))) (let ((?v_1 (c_sort ?v_0 ?p1_93_48)) (?v_2 (c_sort ?v_0 ?p2_92_49))) (= (gt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (> (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun ge_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_6_97_50 c_type)) (forall ((?p1_96_51 c_unique)) (forall ((?p2_95_52 c_unique)) (let ((?v_0 (type_pointer ?t_6_97_50))) (let ((?v_1 (c_sort ?v_0 ?p1_96_51)) (?v_2 (c_sort ?v_0 ?p2_95_52))) (= (ge_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (>= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun valid (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_7_104_53 c_type)) (forall ((?a_103_54 c_unique)) (forall ((?p_102_55 c_unique)) (let ((?v_2 (c_sort type_alloc_table ?a_103_54)) (?v_0 (c_sort (type_pointer ?t_7_104_53) ?p_102_55))) (let ((?v_1 (offset ?v_0))) (= (valid ?v_2 ?v_0) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0)))))))))) +(declare-fun valid_index (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_8_108_56 c_type)) (forall ((?a_107_57 c_unique)) (forall ((?p_106_58 c_unique)) (forall ((?i_105_59 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_107_57)) (?v_0 (c_sort (type_pointer ?t_8_108_56) ?p_106_58))) (let ((?v_1 (+ (offset ?v_0) ?i_105_59))) (= (valid_index ?v_2 ?v_0 ?i_105_59) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0))))))))))) +(declare-fun valid_range (c_ssorted c_ssorted Int Int) Bool) +(assert (forall ((?t_9_113_60 c_type)) (forall ((?a_112_61 c_unique)) (forall ((?p_111_62 c_unique)) (forall ((?i_110_63 Int)) (forall ((?j_109_64 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_112_61)) (?v_0 (c_sort (type_pointer ?t_9_113_60) ?p_111_62))) (let ((?v_1 (offset ?v_0))) (= (valid_range ?v_2 ?v_0 ?i_110_63 ?j_109_64) (and (<= 0 (+ ?v_1 ?i_110_63)) (< (+ ?v_1 ?j_109_64) (block_length ?v_2 ?v_0)))))))))))) +(assert (forall ((?t_10_116_65 c_type)) (forall ((?p_115_66 c_unique)) (forall ((?i_114_67 Int)) (let ((?v_0 (type_pointer ?t_10_116_65))) (let ((?v_1 (c_sort ?v_0 ?p_115_66))) (= (offset (c_sort ?v_0 (shift ?v_1 ?i_114_67))) (+ (offset ?v_1) ?i_114_67)))))))) +(assert (forall ((?t_11_118_68 c_type)) (forall ((?p_117_69 c_unique)) (= (shift (c_sort (type_pointer ?t_11_118_68) ?p_117_69) 0) ?p_117_69)))) +(assert (forall ((?t_12_122_70 c_type)) (forall ((?p_121_71 c_unique)) (forall ((?i_120_72 Int)) (forall ((?j_119_73 Int)) (let ((?v_0 (type_pointer ?t_12_122_70))) (let ((?v_1 (c_sort ?v_0 ?p_121_71))) (= (shift (c_sort ?v_0 (shift ?v_1 ?i_120_72)) ?j_119_73) (shift ?v_1 (+ ?i_120_72 ?j_119_73)))))))))) +(assert (forall ((?t_13_125_74 c_type)) (forall ((?p_124_75 c_unique)) (forall ((?i_123_76 Int)) (let ((?v_0 (type_pointer ?t_13_125_74))) (let ((?v_1 (c_sort ?v_0 ?p_124_75))) (= (base_addr (c_sort ?v_0 (shift ?v_1 ?i_123_76))) (base_addr ?v_1)))))))) +(assert (forall ((?t_14_129_77 c_type)) (forall ((?a_128_78 c_unique)) (forall ((?p_127_79 c_unique)) (forall ((?i_126_80 Int)) (let ((?v_1 (c_sort type_alloc_table ?a_128_78)) (?v_0 (type_pointer ?t_14_129_77))) (let ((?v_2 (c_sort ?v_0 ?p_127_79))) (= (block_length ?v_1 (c_sort ?v_0 (shift ?v_2 ?i_126_80))) (block_length ?v_1 ?v_2))))))))) +(assert (forall ((?t_15_133_81 c_type)) (forall ((?a_132_82 c_unique)) (forall ((?p1_131_83 c_unique)) (forall ((?p2_130_84 c_unique)) (let ((?v_0 (type_pointer ?t_15_133_81))) (let ((?v_1 (c_sort ?v_0 ?p1_131_83)) (?v_3 (c_sort ?v_0 ?p2_130_84)) (?v_2 (c_sort type_alloc_table ?a_132_82))) (=> (= (base_addr ?v_1) (base_addr ?v_3)) (= (block_length ?v_2 ?v_1) (block_length ?v_2 ?v_3)))))))))) +(assert (forall ((?t_16_136_85 c_type)) (forall ((?p1_135_86 c_unique)) (forall ((?p2_134_87 c_unique)) (let ((?v_0 (type_pointer ?t_16_136_85))) (let ((?v_1 (c_sort ?v_0 ?p1_135_86)) (?v_2 (c_sort ?v_0 ?p2_134_87))) (=> (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2))) (= ?p1_135_86 ?p2_134_87)))))))) +(assert (forall ((?t_17_139_88 c_type)) (forall ((?p1_138_89 c_unique)) (forall ((?p2_137_90 c_unique)) (let ((?v_0 (type_pointer ?t_17_139_88))) (let ((?v_1 (c_sort ?v_0 ?p1_138_89)) (?v_2 (c_sort ?v_0 ?p2_137_90))) (=> (= ?p1_138_89 ?p2_137_90) (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2)))))))))) +(assert (forall ((?t_18_144_91 c_type)) (forall ((?p1_143_92 c_unique)) (forall ((?p2_142_93 c_unique)) (forall ((?i_141_94 Int)) (forall ((?j_140_95 Int)) (let ((?v_0 (type_pointer ?t_18_144_91))) (let ((?v_1 (c_sort ?v_0 ?p1_143_92)) (?v_2 (c_sort ?v_0 ?p2_142_93))) (=> (not (= (base_addr ?v_1) (base_addr ?v_2))) (not (= (shift ?v_1 ?i_141_94) (shift ?v_2 ?j_140_95)))))))))))) +(assert (forall ((?t_19_149_96 c_type)) (forall ((?p1_148_97 c_unique)) (forall ((?p2_147_98 c_unique)) (forall ((?i_146_99 Int)) (forall ((?j_145_100 Int)) (let ((?v_0 (type_pointer ?t_19_149_96))) (let ((?v_1 (c_sort ?v_0 ?p1_148_97)) (?v_2 (c_sort ?v_0 ?p2_147_98))) (=> (not (= (+ (offset ?v_1) ?i_146_99) (+ (offset ?v_2) ?j_145_100))) (not (= (shift ?v_1 ?i_146_99) (shift ?v_2 ?j_145_100)))))))))))) +(assert (forall ((?t_20_154_101 c_type)) (forall ((?p1_153_102 c_unique)) (forall ((?p2_152_103 c_unique)) (forall ((?i_151_104 Int)) (forall ((?j_150_105 Int)) (let ((?v_0 (type_pointer ?t_20_154_101))) (let ((?v_1 (c_sort ?v_0 ?p1_153_102)) (?v_2 (c_sort ?v_0 ?p2_152_103))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (=> (= (+ (offset ?v_1) ?i_151_104) (+ (offset ?v_2) ?j_150_105)) (= (shift ?v_1 ?i_151_104) (shift ?v_2 ?j_150_105)))))))))))) +(assert (forall ((?t_21_158_106 c_type)) (forall ((?a_157_107 c_unique)) (forall ((?p_156_108 c_unique)) (forall ((?i_155_109 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_157_107)) (?v_1 (type_pointer ?t_21_158_106))) (let ((?v_2 (c_sort ?v_1 ?p_156_108))) (=> (valid_index ?v_0 ?v_2 ?i_155_109) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?i_155_109))))))))))) +(assert (forall ((?t_22_164_110 c_type)) (forall ((?a_163_111 c_unique)) (forall ((?p_162_112 c_unique)) (forall ((?i_161_113 Int)) (forall ((?j_160_114 Int)) (forall ((?k_159_115 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_163_111)) (?v_1 (type_pointer ?t_22_164_110))) (let ((?v_2 (c_sort ?v_1 ?p_162_112))) (=> (valid_range ?v_0 ?v_2 ?i_161_113 ?j_160_114) (=> (and (<= ?i_161_113 ?k_159_115) (<= ?k_159_115 ?j_160_114)) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?k_159_115)))))))))))))) +(assert (forall ((?t_23_169_116 c_type)) (forall ((?a_168_117 c_unique)) (forall ((?p_167_118 c_unique)) (forall ((?i_166_119 Int)) (forall ((?j_165_120 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_168_117)) (?v_1 (c_sort (type_pointer ?t_23_169_116) ?p_167_118))) (=> (valid_range ?v_0 ?v_1 ?i_166_119 ?j_165_120) (=> (and (<= ?i_166_119 0) (<= 0 ?j_165_120)) (valid ?v_0 ?v_1)))))))))) +(assert (forall ((?t_24_175_121 c_type)) (forall ((?a_174_122 c_unique)) (forall ((?p_173_123 c_unique)) (forall ((?i_172_124 Int)) (forall ((?j_171_125 Int)) (forall ((?k_170_126 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_174_122)) (?v_1 (c_sort (type_pointer ?t_24_175_121) ?p_173_123))) (=> (valid_range ?v_0 ?v_1 ?i_172_124 ?j_171_125) (=> (and (<= ?i_172_124 ?k_170_126) (<= ?k_170_126 ?j_171_125)) (valid_index ?v_0 ?v_1 ?k_170_126))))))))))) +(assert (forall ((?t_25_178_127 c_type)) (forall ((?p1_177_128 c_unique)) (forall ((?p2_176_129 c_unique)) (let ((?v_0 (type_pointer ?t_25_178_127))) (let ((?v_1 (c_sort ?v_0 ?p1_177_128)) (?v_2 (c_sort ?v_0 ?p2_176_129))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (= (sub_pointer ?v_1 ?v_2) (- (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun type_memory (c_type c_type) c_type) +(declare-fun acc (c_ssorted c_ssorted) c_unique) +(declare-fun upd (c_ssorted c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_27_212_130 c_type)) (forall ((?t_26_211_131 c_type)) (forall ((?m_210_132 c_unique)) (forall ((?p_209_133 c_unique)) (forall ((?a_208_134 c_unique)) (let ((?v_0 (type_memory ?t_26_211_131 ?t_27_212_130)) (?v_1 (c_sort (type_pointer ?t_27_212_130) ?p_209_133))) (= (acc (c_sort ?v_0 (upd (c_sort ?v_0 ?m_210_132) ?v_1 (c_sort ?t_26_211_131 ?a_208_134))) ?v_1) ?a_208_134)))))))) +(assert (forall ((?t_29_218_135 c_type)) (forall ((?t_28_217_136 c_type)) (forall ((?m_216_137 c_unique)) (forall ((?p1_215_138 c_unique)) (forall ((?p2_214_139 c_unique)) (forall ((?a_213_140 c_unique)) (let ((?v_0 (type_memory ?t_28_217_136 ?t_29_218_135))) (let ((?v_2 (c_sort ?v_0 ?m_216_137)) (?v_1 (type_pointer ?t_29_218_135))) (let ((?v_3 (c_sort ?v_1 ?p2_214_139))) (=> (not (= ?p1_215_138 ?p2_214_139)) (= (acc (c_sort ?v_0 (upd ?v_2 (c_sort ?v_1 ?p1_215_138) (c_sort ?t_28_217_136 ?a_213_140))) ?v_3) (acc ?v_2 ?v_3))))))))))))) +(assert (not (= c_Boolean_false c_Boolean_true))) +(declare-fun type_pset (c_type) c_type) +(declare-fun pset_empty () c_unique) +(declare-fun pset_singleton (c_ssorted) c_unique) +(declare-fun pset_star (c_ssorted c_ssorted) c_unique) +(declare-fun pset_all (c_ssorted) c_unique) +(declare-fun pset_range (c_ssorted Int Int) c_unique) +(declare-fun pset_range_left (c_ssorted Int) c_unique) +(declare-fun pset_range_right (c_ssorted Int) c_unique) +(declare-fun pset_acc_all (c_ssorted c_ssorted) c_unique) +(declare-fun pset_acc_range (c_ssorted c_ssorted Int Int) c_unique) +(declare-fun pset_acc_range_left (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_acc_range_right (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_union (c_ssorted c_ssorted) c_unique) +(declare-fun not_in_pset (c_ssorted c_ssorted) Bool) +(declare-fun not_assigns (c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_31_225_141 c_type)) (forall ((?t_30_224_142 c_type)) (forall ((?a_223_143 c_unique)) (forall ((?m1_222_144 c_unique)) (forall ((?m2_221_145 c_unique)) (forall ((?l_220_146 c_unique)) (let ((?v_0 (type_memory ?t_30_224_142 ?t_31_225_141))) (= (not_assigns (c_sort type_alloc_table ?a_223_143) (c_sort ?v_0 ?m1_222_144) (c_sort ?v_0 ?m2_221_145) (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (forall ((?p_219_147 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_31_225_141) ?p_219_147))) (=> (valid (c_sort type_alloc_table ?a_223_143) ?v_1) (=> (not_in_pset ?v_1 (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (= (acc (c_sort ?v_0 ?m2_221_145) ?v_1) (acc (c_sort ?v_0 ?m1_222_144) ?v_1))))))))))))))) +(assert (forall ((?t_32_227_148 c_type)) (forall ((?p_226_149 c_unique)) (not_in_pset (c_sort (type_pointer ?t_32_227_148) ?p_226_149) (c_sort (type_pset ?t_32_227_148) pset_empty))))) +(assert (forall ((?t_33_230_150 c_type)) (forall ((?p1_229_151 c_unique)) (forall ((?p2_228_152 c_unique)) (let ((?v_0 (type_pointer ?t_33_230_150))) (=> (not (= ?p1_229_151 ?p2_228_152)) (not_in_pset (c_sort ?v_0 ?p1_229_151) (c_sort (type_pset ?t_33_230_150) (pset_singleton (c_sort ?v_0 ?p2_228_152)))))))))) +(assert (forall ((?t_34_233_153 c_type)) (forall ((?p1_232_154 c_unique)) (forall ((?p2_231_155 c_unique)) (let ((?v_0 (type_pointer ?t_34_233_153))) (=> (not_in_pset (c_sort ?v_0 ?p1_232_154) (c_sort (type_pset ?t_34_233_153) (pset_singleton (c_sort ?v_0 ?p2_231_155)))) (not (= ?p1_232_154 ?p2_231_155)))))))) +(assert (forall ((?t_35_235_156 c_type)) (forall ((?p_234_157 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_35_235_156) ?p_234_157))) (not (not_in_pset ?v_0 (c_sort (type_pset ?t_35_235_156) (pset_singleton ?v_0)))))))) +(assert (forall ((?t_36_239_158 c_type)) (forall ((?l1_238_159 c_unique)) (forall ((?l2_237_160 c_unique)) (forall ((?p_236_161 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_36_239_158) ?p_236_161)) (?v_1 (type_pset ?t_36_239_158))) (let ((?v_2 (c_sort ?v_1 ?l1_238_159)) (?v_3 (c_sort ?v_1 ?l2_237_160))) (=> (and (not_in_pset ?v_0 ?v_2) (not_in_pset ?v_0 ?v_3)) (not_in_pset ?v_0 (c_sort ?v_1 (pset_union ?v_2 ?v_3))))))))))) +(assert (forall ((?t_37_243_162 c_type)) (forall ((?l1_242_163 c_unique)) (forall ((?l2_241_164 c_unique)) (forall ((?p_240_165 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_37_243_162) ?p_240_165)) (?v_0 (type_pset ?t_37_243_162))) (let ((?v_2 (c_sort ?v_0 ?l1_242_163))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union ?v_2 (c_sort ?v_0 ?l2_241_164)))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_38_247_166 c_type)) (forall ((?l1_246_167 c_unique)) (forall ((?l2_245_168 c_unique)) (forall ((?p_244_169 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_38_247_166) ?p_244_169)) (?v_0 (type_pset ?t_38_247_166))) (let ((?v_2 (c_sort ?v_0 ?l2_245_168))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union (c_sort ?v_0 ?l1_246_167) ?v_2))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_40_253_170 c_type)) (forall ((?t_39_252_171 c_type)) (forall ((?l_251_172 c_unique)) (forall ((?m_250_173 c_unique)) (forall ((?p_249_174 c_unique)) (let ((?v_0 (type_pointer ?t_40_253_170))) (=> (forall ((?p1_248_175 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_39_252_171) ?p1_248_175))) (=> (= ?p_249_174 (acc (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_39_252_171) ?l_251_172))))) (not_in_pset (c_sort ?v_0 ?p_249_174) (c_sort (type_pset ?t_40_253_170) (pset_star (c_sort (type_pset ?t_39_252_171) ?l_251_172) (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173)))))))))))) +(assert (forall ((?t_42_259_176 c_type)) (forall ((?t_41_258_177 c_type)) (forall ((?l_257_178 c_unique)) (forall ((?m_256_179 c_unique)) (forall ((?p_255_180 c_unique)) (let ((?v_0 (type_pointer ?t_42_259_176))) (=> (not_in_pset (c_sort ?v_0 ?p_255_180) (c_sort (type_pset ?t_42_259_176) (pset_star (c_sort (type_pset ?t_41_258_177) ?l_257_178) (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179)))) (forall ((?p1_254_181 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_41_258_177) ?p1_254_181))) (=> (= ?p_255_180 (acc (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_41_258_177) ?l_257_178))))))))))))) +(assert (forall ((?t_43_263_182 c_type)) (forall ((?p_262_183 c_unique)) (forall ((?l_261_184 c_unique)) (let ((?v_0 (type_pset ?t_43_263_182))) (=> (forall ((?p1_260_185 c_unique)) (let ((?v_1 (type_pointer ?t_43_263_182))) (let ((?v_2 (c_sort ?v_1 ?p1_260_185))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_261_184))) (not (= (base_addr (c_sort ?v_1 ?p_262_183)) (base_addr ?v_2))))))) (not_in_pset (c_sort (type_pointer ?t_43_263_182) ?p_262_183) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_261_184)))))))))) +(assert (forall ((?t_44_267_186 c_type)) (forall ((?p_266_187 c_unique)) (forall ((?l_265_188 c_unique)) (let ((?v_0 (type_pset ?t_44_267_186))) (=> (not_in_pset (c_sort (type_pointer ?t_44_267_186) ?p_266_187) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_265_188)))) (forall ((?p1_264_189 c_unique)) (let ((?v_1 (type_pointer ?t_44_267_186))) (let ((?v_2 (c_sort ?v_1 ?p1_264_189))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_265_188))) (not (= (base_addr (c_sort ?v_1 ?p_266_187)) (base_addr ?v_2))))))))))))) +(assert (forall ((?t_45_274_190 c_type)) (forall ((?p_273_191 c_unique)) (forall ((?l_272_192 c_unique)) (forall ((?a_271_193 Int)) (forall ((?b_270_194 Int)) (let ((?v_0 (type_pset ?t_45_274_190))) (=> (forall ((?p1_269_195 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) (c_sort ?v_0 ?l_272_192)) (forall ((?i_268_196 Int)) (=> (and (<= ?a_271_193 ?i_268_196) (<= ?i_268_196 ?b_270_194)) (not (= ?p_273_191 (shift (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) ?i_268_196))))))) (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p_273_191) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_272_192) ?a_271_193 ?b_270_194))))))))))) +(assert (forall ((?t_46_281_197 c_type)) (forall ((?p_280_198 c_unique)) (forall ((?l_279_199 c_unique)) (forall ((?a_278_200 Int)) (forall ((?b_277_201 Int)) (let ((?v_0 (type_pset ?t_46_281_197))) (=> (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p_280_198) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_279_199) ?a_278_200 ?b_277_201))) (forall ((?p1_276_202 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) (c_sort ?v_0 ?l_279_199))) (forall ((?i_275_203 Int)) (=> (and (<= ?a_278_200 ?i_275_203) (<= ?i_275_203 ?b_277_201)) (not (= (shift (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) ?i_275_203) ?p_280_198)))))))))))))) +(assert (forall ((?t_47_287_204 c_type)) (forall ((?p_286_205 c_unique)) (forall ((?l_285_206 c_unique)) (forall ((?a_284_207 Int)) (let ((?v_0 (type_pset ?t_47_287_204))) (=> (forall ((?p1_283_208 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) (c_sort ?v_0 ?l_285_206)) (forall ((?i_282_209 Int)) (=> (<= ?i_282_209 ?a_284_207) (not (= ?p_286_205 (shift (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) ?i_282_209))))))) (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p_286_205) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_285_206) ?a_284_207)))))))))) +(assert (forall ((?t_48_293_210 c_type)) (forall ((?p_292_211 c_unique)) (forall ((?l_291_212 c_unique)) (forall ((?a_290_213 Int)) (let ((?v_0 (type_pset ?t_48_293_210))) (=> (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p_292_211) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_291_212) ?a_290_213))) (forall ((?p1_289_214 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) (c_sort ?v_0 ?l_291_212))) (forall ((?i_288_215 Int)) (=> (<= ?i_288_215 ?a_290_213) (not (= (shift (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) ?i_288_215) ?p_292_211))))))))))))) +(assert (forall ((?t_49_299_216 c_type)) (forall ((?p_298_217 c_unique)) (forall ((?l_297_218 c_unique)) (forall ((?a_296_219 Int)) (let ((?v_0 (type_pset ?t_49_299_216))) (=> (forall ((?p1_295_220 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) (c_sort ?v_0 ?l_297_218)) (forall ((?i_294_221 Int)) (=> (<= ?a_296_219 ?i_294_221) (not (= ?p_298_217 (shift (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) ?i_294_221))))))) (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p_298_217) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_297_218) ?a_296_219)))))))))) +(assert (forall ((?t_50_305_222 c_type)) (forall ((?p_304_223 c_unique)) (forall ((?l_303_224 c_unique)) (forall ((?a_302_225 Int)) (let ((?v_0 (type_pset ?t_50_305_222))) (=> (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p_304_223) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_303_224) ?a_302_225))) (forall ((?p1_301_226 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) (c_sort ?v_0 ?l_303_224))) (forall ((?i_300_227 Int)) (=> (<= ?a_302_225 ?i_300_227) (not (= (shift (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) ?i_300_227) ?p_304_223))))))))))))) +(assert (forall ((?t_52_312_228 c_type)) (forall ((?t_51_311_229 c_type)) (forall ((?p_310_230 c_unique)) (forall ((?l_309_231 c_unique)) (forall ((?m_308_232 c_unique)) (let ((?v_0 (type_pointer ?t_51_311_229))) (=> (forall ((?p1_307_233 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_52_312_228) ?p1_307_233) (c_sort (type_pset ?t_52_312_228) ?l_309_231))) (forall ((?i_306_234 Int)) (let ((?v_1 (type_pointer ?t_52_312_228))) (not (= ?p_310_230 (acc (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_307_233) ?i_306_234))))))))) (not_in_pset (c_sort ?v_0 ?p_310_230) (c_sort (type_pset ?t_51_311_229) (pset_acc_all (c_sort (type_pset ?t_52_312_228) ?l_309_231) (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232)))))))))))) +(assert (forall ((?t_54_319_235 c_type)) (forall ((?t_53_318_236 c_type)) (forall ((?p_317_237 c_unique)) (forall ((?l_316_238 c_unique)) (forall ((?m_315_239 c_unique)) (let ((?v_0 (type_pointer ?t_53_318_236))) (=> (not_in_pset (c_sort ?v_0 ?p_317_237) (c_sort (type_pset ?t_53_318_236) (pset_acc_all (c_sort (type_pset ?t_54_319_235) ?l_316_238) (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239)))) (forall ((?p1_314_240 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_54_319_235) ?p1_314_240) (c_sort (type_pset ?t_54_319_235) ?l_316_238))) (forall ((?i_313_241 Int)) (let ((?v_1 (type_pointer ?t_54_319_235))) (not (= (acc (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_314_240) ?i_313_241))) ?p_317_237)))))))))))))) +(assert (forall ((?t_56_328_242 c_type)) (forall ((?t_55_327_243 c_type)) (forall ((?p_326_244 c_unique)) (forall ((?l_325_245 c_unique)) (forall ((?m_324_246 c_unique)) (forall ((?a_323_247 Int)) (forall ((?b_322_248 Int)) (let ((?v_0 (type_pointer ?t_55_327_243))) (=> (forall ((?p1_321_249 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_56_328_242) ?p1_321_249) (c_sort (type_pset ?t_56_328_242) ?l_325_245))) (forall ((?i_320_250 Int)) (let ((?v_1 (type_pointer ?t_56_328_242))) (=> (and (<= ?a_323_247 ?i_320_250) (<= ?i_320_250 ?b_322_248)) (not (= ?p_326_244 (acc (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_321_249) ?i_320_250)))))))))) (not_in_pset (c_sort ?v_0 ?p_326_244) (c_sort (type_pset ?t_55_327_243) (pset_acc_range (c_sort (type_pset ?t_56_328_242) ?l_325_245) (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) ?a_323_247 ?b_322_248))))))))))))) +(assert (forall ((?t_58_337_251 c_type)) (forall ((?t_57_336_252 c_type)) (forall ((?p_335_253 c_unique)) (forall ((?l_334_254 c_unique)) (forall ((?m_333_255 c_unique)) (forall ((?a_332_256 Int)) (forall ((?b_331_257 Int)) (let ((?v_0 (type_pointer ?t_57_336_252))) (=> (not_in_pset (c_sort ?v_0 ?p_335_253) (c_sort (type_pset ?t_57_336_252) (pset_acc_range (c_sort (type_pset ?t_58_337_251) ?l_334_254) (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) ?a_332_256 ?b_331_257))) (forall ((?p1_330_258 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_58_337_251) ?p1_330_258) (c_sort (type_pset ?t_58_337_251) ?l_334_254))) (forall ((?i_329_259 Int)) (let ((?v_1 (type_pointer ?t_58_337_251))) (=> (and (<= ?a_332_256 ?i_329_259) (<= ?i_329_259 ?b_331_257)) (not (= (acc (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_330_258) ?i_329_259))) ?p_335_253))))))))))))))))) +(assert (forall ((?t_60_345_260 c_type)) (forall ((?t_59_344_261 c_type)) (forall ((?p_343_262 c_unique)) (forall ((?l_342_263 c_unique)) (forall ((?m_341_264 c_unique)) (forall ((?a_340_265 Int)) (let ((?v_0 (type_pointer ?t_59_344_261))) (=> (forall ((?p1_339_266 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_60_345_260) ?p1_339_266) (c_sort (type_pset ?t_60_345_260) ?l_342_263))) (forall ((?i_338_267 Int)) (let ((?v_1 (type_pointer ?t_60_345_260))) (=> (<= ?i_338_267 ?a_340_265) (not (= ?p_343_262 (acc (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_339_266) ?i_338_267)))))))))) (not_in_pset (c_sort ?v_0 ?p_343_262) (c_sort (type_pset ?t_59_344_261) (pset_acc_range_left (c_sort (type_pset ?t_60_345_260) ?l_342_263) (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) ?a_340_265)))))))))))) +(assert (forall ((?t_62_353_268 c_type)) (forall ((?t_61_352_269 c_type)) (forall ((?p_351_270 c_unique)) (forall ((?l_350_271 c_unique)) (forall ((?m_349_272 c_unique)) (forall ((?a_348_273 Int)) (let ((?v_0 (type_pointer ?t_61_352_269))) (=> (not_in_pset (c_sort ?v_0 ?p_351_270) (c_sort (type_pset ?t_61_352_269) (pset_acc_range_left (c_sort (type_pset ?t_62_353_268) ?l_350_271) (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) ?a_348_273))) (forall ((?p1_347_274 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_62_353_268) ?p1_347_274) (c_sort (type_pset ?t_62_353_268) ?l_350_271))) (forall ((?i_346_275 Int)) (let ((?v_1 (type_pointer ?t_62_353_268))) (=> (<= ?i_346_275 ?a_348_273) (not (= (acc (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_347_274) ?i_346_275))) ?p_351_270)))))))))))))))) +(assert (forall ((?t_64_361_276 c_type)) (forall ((?t_63_360_277 c_type)) (forall ((?p_359_278 c_unique)) (forall ((?l_358_279 c_unique)) (forall ((?m_357_280 c_unique)) (forall ((?a_356_281 Int)) (let ((?v_0 (type_pointer ?t_63_360_277))) (=> (forall ((?p1_355_282 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_64_361_276) ?p1_355_282) (c_sort (type_pset ?t_64_361_276) ?l_358_279))) (forall ((?i_354_283 Int)) (let ((?v_1 (type_pointer ?t_64_361_276))) (=> (<= ?a_356_281 ?i_354_283) (not (= ?p_359_278 (acc (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_355_282) ?i_354_283)))))))))) (not_in_pset (c_sort ?v_0 ?p_359_278) (c_sort (type_pset ?t_63_360_277) (pset_acc_range_right (c_sort (type_pset ?t_64_361_276) ?l_358_279) (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) ?a_356_281)))))))))))) +(assert (forall ((?t_66_369_284 c_type)) (forall ((?t_65_368_285 c_type)) (forall ((?p_367_286 c_unique)) (forall ((?l_366_287 c_unique)) (forall ((?m_365_288 c_unique)) (forall ((?a_364_289 Int)) (let ((?v_0 (type_pointer ?t_65_368_285))) (=> (not_in_pset (c_sort ?v_0 ?p_367_286) (c_sort (type_pset ?t_65_368_285) (pset_acc_range_right (c_sort (type_pset ?t_66_369_284) ?l_366_287) (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) ?a_364_289))) (forall ((?p1_363_290 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_66_369_284) ?p1_363_290) (c_sort (type_pset ?t_66_369_284) ?l_366_287))) (forall ((?i_362_291 Int)) (let ((?v_1 (type_pointer ?t_66_369_284))) (=> (<= ?a_364_289 ?i_362_291) (not (= (acc (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_363_290) ?i_362_291))) ?p_367_286)))))))))))))))) +(assert (forall ((?t_68_376_292 c_type)) (forall ((?t_67_375_293 c_type)) (forall ((?a_374_294 c_unique)) (forall ((?l_373_295 c_unique)) (forall ((?m1_372_296 c_unique)) (forall ((?m2_371_297 c_unique)) (forall ((?m3_370_298 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a_374_294)) (?v_0 (type_memory ?t_68_376_292 ?t_67_375_293))) (let ((?v_4 (c_sort ?v_0 ?m1_372_296)) (?v_2 (c_sort ?v_0 ?m2_371_297)) (?v_3 (c_sort (type_pset ?t_67_375_293) ?l_373_295)) (?v_5 (c_sort ?v_0 ?m3_370_298))) (=> (not_assigns ?v_1 ?v_4 ?v_2 ?v_3) (=> (not_assigns ?v_1 ?v_2 ?v_5 ?v_3) (not_assigns ?v_1 ?v_4 ?v_5 ?v_3))))))))))))) +(assert (forall ((?t_70_381_299 c_type)) (forall ((?t_69_380_300 c_type)) (forall ((?a_379_301 c_unique)) (forall ((?l_378_302 c_unique)) (forall ((?m_377_303 c_unique)) (let ((?v_0 (c_sort (type_memory ?t_70_381_299 ?t_69_380_300) ?m_377_303))) (not_assigns (c_sort type_alloc_table ?a_379_301) ?v_0 ?v_0 (c_sort (type_pset ?t_69_380_300) ?l_378_302))))))))) +(declare-fun valid_acc (c_ssorted) Bool) +(assert (forall ((?t_72_386_304 c_type)) (forall ((?t_71_385_305 c_type)) (forall ((?m1_384_306 c_unique)) (= (valid_acc (c_sort (type_memory (type_pointer ?t_71_385_305) ?t_72_386_304) ?m1_384_306)) (forall ((?p_383_307 c_unique)) (forall ((?a_382_308 c_unique)) (let ((?v_1 (type_pointer ?t_71_385_305)) (?v_0 (c_sort type_alloc_table ?a_382_308)) (?v_2 (c_sort (type_pointer ?t_72_386_304) ?p_383_307))) (=> (valid ?v_0 ?v_2) (valid ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_72_386_304) ?m1_384_306) ?v_2)))))))))))) +(declare-fun valid_acc_range (c_ssorted Int) Bool) +(assert (forall ((?t_74_392_309 c_type)) (forall ((?t_73_391_310 c_type)) (forall ((?m1_390_311 c_unique)) (forall ((?size_389_312 Int)) (= (valid_acc_range (c_sort (type_memory (type_pointer ?t_73_391_310) ?t_74_392_309) ?m1_390_311) ?size_389_312) (forall ((?p_388_313 c_unique)) (forall ((?a_387_314 c_unique)) (let ((?v_1 (type_pointer ?t_73_391_310)) (?v_0 (c_sort type_alloc_table ?a_387_314)) (?v_2 (c_sort (type_pointer ?t_74_392_309) ?p_388_313))) (=> (valid ?v_0 ?v_2) (valid_range ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_74_392_309) ?m1_390_311) ?v_2)) 0 (- ?size_389_312 1)))))))))))) +(assert (forall ((?t_76_398_315 c_type)) (forall ((?t_75_397_316 c_type)) (forall ((?m1_396_317 c_unique)) (forall ((?size_395_318 Int)) (forall ((?p_394_319 c_unique)) (forall ((?a_393_320 c_unique)) (let ((?v_1 (type_pointer ?t_75_397_316))) (let ((?v_2 (c_sort (type_memory ?v_1 ?t_76_398_315) ?m1_396_317)) (?v_0 (c_sort type_alloc_table ?a_393_320)) (?v_3 (c_sort (type_pointer ?t_76_398_315) ?p_394_319))) (=> (valid_acc_range ?v_2 ?size_395_318) (=> (valid ?v_0 ?v_3) (valid ?v_0 (c_sort ?v_1 (acc ?v_2 ?v_3)))))))))))))) +(declare-fun separation1 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_78_404_321 c_type)) (forall ((?t_77_403_322 c_type)) (forall ((?m1_402_323 c_unique)) (forall ((?m2_401_324 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_77_403_322) ?t_78_404_321))) (= (separation1 (c_sort ?v_0 ?m1_402_323) (c_sort ?v_0 ?m2_401_324)) (forall ((?p_400_325 c_unique)) (forall ((?a_399_326 c_unique)) (let ((?v_1 (type_pointer ?t_77_403_322)) (?v_2 (c_sort (type_pointer ?t_78_404_321) ?p_400_325))) (=> (valid (c_sort type_alloc_table ?a_399_326) ?v_2) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_402_323) ?v_2))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_401_324) ?v_2)))))))))))))))) +(declare-fun separation1_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_80_412_327 c_type)) (forall ((?t_79_411_328 c_type)) (forall ((?m1_410_329 c_unique)) (forall ((?m2_409_330 c_unique)) (forall ((?size_408_331 Int)) (let ((?v_0 (type_memory (type_pointer ?t_79_411_328) ?t_80_412_327))) (= (separation1_range1 (c_sort ?v_0 ?m1_410_329) (c_sort ?v_0 ?m2_409_330) ?size_408_331) (forall ((?p_407_332 c_unique)) (forall ((?a_406_333 c_unique)) (=> (valid (c_sort type_alloc_table ?a_406_333) (c_sort (type_pointer ?t_80_412_327) ?p_407_332)) (forall ((?i_405_334 Int)) (let ((?v_1 (type_pointer ?t_79_411_328)) (?v_2 (type_pointer ?t_80_412_327))) (let ((?v_3 (c_sort ?v_2 ?p_407_332))) (=> (and (<= 0 ?i_405_334) (< ?i_405_334 ?size_408_331)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_410_329) (c_sort ?v_2 (shift ?v_3 ?i_405_334))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_409_330) ?v_3)))))))))))))))))))) +(declare-fun separation1_range (c_ssorted Int) Bool) +(assert (forall ((?t_82_420_335 c_type)) (forall ((?t_81_419_336 c_type)) (forall ((?m_418_337 c_unique)) (forall ((?size_417_338 Int)) (= (separation1_range (c_sort (type_memory (type_pointer ?t_81_419_336) ?t_82_420_335) ?m_418_337) ?size_417_338) (forall ((?p_416_339 c_unique)) (forall ((?a_415_340 c_unique)) (=> (valid (c_sort type_alloc_table ?a_415_340) (c_sort (type_pointer ?t_82_420_335) ?p_416_339)) (forall ((?i1_414_341 Int)) (forall ((?i2_413_342 Int)) (let ((?v_0 (type_pointer ?t_81_419_336))) (let ((?v_2 (c_sort (type_memory ?v_0 ?t_82_420_335) ?m_418_337)) (?v_1 (type_pointer ?t_82_420_335))) (let ((?v_3 (c_sort ?v_1 ?p_416_339))) (=> (and (<= 0 ?i1_414_341) (< ?i1_414_341 ?size_417_338)) (=> (and (<= 0 ?i2_413_342) (< ?i2_413_342 ?size_417_338)) (=> (not (= ?i1_414_341 ?i2_413_342)) (not (= (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i1_414_341))))) (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i2_413_342)))))))))))))))))))))))) +(declare-fun separation2 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_84_426_343 c_type)) (forall ((?t_83_425_344 c_type)) (forall ((?m1_424_345 c_unique)) (forall ((?m2_423_346 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_83_425_344) ?t_84_426_343))) (= (separation2 (c_sort ?v_0 ?m1_424_345) (c_sort ?v_0 ?m2_423_346)) (forall ((?p1_422_347 c_unique)) (forall ((?p2_421_348 c_unique)) (let ((?v_1 (type_pointer ?t_83_425_344)) (?v_2 (type_pointer ?t_84_426_343))) (=> (not (= ?p1_422_347 ?p2_421_348)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_424_345) (c_sort ?v_2 ?p1_422_347)))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_423_346) (c_sort ?v_2 ?p2_421_348))))))))))))))))) +(declare-fun separation2_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_86_435_349 c_type)) (forall ((?t_85_434_350 c_type)) (forall ((?m1_433_351 c_unique)) (forall ((?m2_432_352 c_unique)) (forall ((?size_431_353 Int)) (let ((?v_0 (type_memory (type_pointer ?t_85_434_350) ?t_86_435_349))) (= (separation2_range1 (c_sort ?v_0 ?m1_433_351) (c_sort ?v_0 ?m2_432_352) ?size_431_353) (forall ((?p_430_354 c_unique)) (forall ((?q_429_355 c_unique)) (forall ((?a_428_356 c_unique)) (forall ((?i_427_357 Int)) (let ((?v_1 (type_pointer ?t_85_434_350)) (?v_2 (type_pointer ?t_86_435_349))) (=> (and (<= 0 ?i_427_357) (< ?i_427_357 ?size_431_353)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_433_351) (c_sort ?v_2 (shift (c_sort ?v_2 ?p_430_354) ?i_427_357))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_432_352) (c_sort ?v_2 ?q_429_355)))))))))))))))))))) +(declare-fun on_heap (c_ssorted c_ssorted) Bool) +(declare-fun on_stack (c_ssorted c_ssorted) Bool) +(declare-fun fresh (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_87_438_358 c_type)) (forall ((?a_437_359 c_unique)) (forall ((?p_436_360 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_437_359)) (?v_1 (c_sort (type_pointer ?t_87_438_358) ?p_436_360))) (=> (fresh ?v_0 ?v_1) (not (valid ?v_0 ?v_1)))))))) +(assert (forall ((?t_88_442_361 c_type)) (forall ((?a_441_362 c_unique)) (forall ((?p_440_363 c_unique)) (=> (fresh (c_sort type_alloc_table ?a_441_362) (c_sort (type_pointer ?t_88_442_361) ?p_440_363)) (forall ((?i_439_364 Int)) (let ((?v_0 (type_pointer ?t_88_442_361))) (not (valid (c_sort type_alloc_table ?a_441_362) (c_sort ?v_0 (shift (c_sort ?v_0 ?p_440_363) ?i_439_364))))))))))) +(declare-fun alloc_extends (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_89_446_365 c_type)) (forall ((?a1_445_366 c_unique)) (forall ((?a2_444_367 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_445_366) (c_sort type_alloc_table ?a2_444_367)) (forall ((?q_443_368 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_89_446_365) ?q_443_368))) (=> (valid (c_sort type_alloc_table ?a1_445_366) ?v_0) (valid (c_sort type_alloc_table ?a2_444_367) ?v_0))))))))) +(assert (forall ((?t_90_451_369 c_type)) (forall ((?a1_450_370 c_unique)) (forall ((?a2_449_371 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_450_370) (c_sort type_alloc_table ?a2_449_371)) (forall ((?q_448_372 c_unique)) (forall ((?i_447_373 Int)) (let ((?v_0 (c_sort (type_pointer ?t_90_451_369) ?q_448_372))) (=> (valid_index (c_sort type_alloc_table ?a1_450_370) ?v_0 ?i_447_373) (valid_index (c_sort type_alloc_table ?a2_449_371) ?v_0 ?i_447_373)))))))))) +(assert (forall ((?t_91_457_374 c_type)) (forall ((?a1_456_375 c_unique)) (forall ((?a2_455_376 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_456_375) (c_sort type_alloc_table ?a2_455_376)) (forall ((?q_454_377 c_unique)) (forall ((?i_453_378 Int)) (forall ((?j_452_379 Int)) (let ((?v_0 (c_sort (type_pointer ?t_91_457_374) ?q_454_377))) (=> (valid_range (c_sort type_alloc_table ?a1_456_375) ?v_0 ?i_453_378 ?j_452_379) (valid_range (c_sort type_alloc_table ?a2_455_376) ?v_0 ?i_453_378 ?j_452_379))))))))))) +(assert (forall ((?a_458_380 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_458_380))) (alloc_extends ?v_0 ?v_0)))) +(assert (forall ((?a1_461_381 c_unique)) (forall ((?a2_460_382 c_unique)) (forall ((?a3_459_383 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a1_461_381)) (?v_0 (c_sort type_alloc_table ?a2_460_382)) (?v_2 (c_sort type_alloc_table ?a3_459_383))) (=> (alloc_extends ?v_1 ?v_0) (=> (alloc_extends ?v_0 ?v_2) (alloc_extends ?v_1 ?v_2)))))))) +(declare-fun free_stack (c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_92_466_384 c_type)) (forall ((?a1_465_385 c_unique)) (forall ((?a2_464_386 c_unique)) (forall ((?a3_463_387 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_465_385) (c_sort type_alloc_table ?a2_464_386) (c_sort type_alloc_table ?a3_463_387)) (forall ((?p_462_388 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a2_464_386)) (?v_1 (c_sort (type_pointer ?t_92_466_384) ?p_462_388))) (=> (valid ?v_0 ?v_1) (=> (on_heap ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_463_387) ?v_1))))))))))) +(assert (forall ((?t_93_471_389 c_type)) (forall ((?a1_470_390 c_unique)) (forall ((?a2_469_391 c_unique)) (forall ((?a3_468_392 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_470_390) (c_sort type_alloc_table ?a2_469_391) (c_sort type_alloc_table ?a3_468_392)) (forall ((?p_467_393 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a1_470_390)) (?v_1 (c_sort (type_pointer ?t_93_471_389) ?p_467_393))) (=> (valid ?v_0 ?v_1) (=> (on_stack ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_468_392) ?v_1))))))))))) +(declare-fun null () c_unique) +(assert (forall ((?t_94_475_394 c_type)) (forall ((?a_474_395 c_unique)) (not (valid (c_sort type_alloc_table ?a_474_395) (c_sort (type_pointer ?t_94_475_394) null)))))) +(declare-fun type_global () c_type) +(declare-fun separation_anonymous_0_int (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?x_global_489_396 c_unique)) (forall ((?anonymous_0PM_global_488_397 c_unique)) (forall ((?tab_487_398 c_unique)) (forall ((?v_486_399 c_unique)) (forall ((?alloc_485_400 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global)) (?v_2 (c_sort ?v_1 ?tab_487_398)) (?v_3 (c_sort ?v_1 ?v_486_399))) (= (separation_anonymous_0_int (c_sort ?v_0 ?x_global_489_396) (c_sort ?v_0 ?anonymous_0PM_global_488_397) ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_485_400)) (and (not (= (base_addr ?v_2) (base_addr ?v_3))) (forall ((?index_3_484_401 Int)) (=> (and (<= 0 ?index_3_484_401) (< ?index_3_484_401 5)) (not (= (base_addr ?v_3) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?x_global_489_396) (c_sort ?v_1 (acc (c_sort ?v_0 ?anonymous_0PM_global_488_397) (c_sort ?v_1 (shift ?v_2 ?index_3_484_401))))))))))))))))))))) +(declare-fun separation_anonymous_0_s1 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?x_global_498_402 c_unique)) (forall ((?u_global_497_403 c_unique)) (forall ((?t_global_496_404 c_unique)) (forall ((?s1PM_global_495_405 c_unique)) (forall ((?anonymous_0PM_global_494_406 c_unique)) (forall ((?tab_493_407 c_unique)) (forall ((?s_492_408 c_unique)) (forall ((?alloc_491_409 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?u_global_497_403)) (?v_5 (c_sort ?v_0 ?t_global_496_404)) (?v_6 (c_sort ?v_0 ?s1PM_global_495_405)) (?v_2 (c_sort ?v_1 ?tab_493_407)) (?v_3 (c_sort ?v_1 ?s_492_408))) (let ((?v_4 (base_addr ?v_2)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_3)))) (= (separation_anonymous_0_s1 (c_sort ?v_0 ?x_global_498_402) ?v_7 ?v_5 ?v_6 (c_sort ?v_0 ?anonymous_0PM_global_494_406) ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_491_409)) (and (not (= ?v_4 (base_addr ?v_3))) (and (forall ((?index_6_490_410 Int)) (=> (and (<= 0 ?index_6_490_410) (< ?index_6_490_410 5)) (not (= (base_addr ?v_3) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?x_global_498_402) (c_sort ?v_1 (acc (c_sort ?v_0 ?anonymous_0PM_global_494_406) (c_sort ?v_1 (shift ?v_2 ?index_6_490_410))))))))))) (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))))))))))))))))))) +(declare-fun separation_anonymous_1_anonymous_0 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?x_global_507_411 c_unique)) (forall ((?p2_global_506_412 c_unique)) (forall ((?p1_global_505_413 c_unique)) (forall ((?anonymous_1PM_global_504_414 c_unique)) (forall ((?anonymous_0PM_global_503_415 c_unique)) (forall ((?u1_502_416 c_unique)) (forall ((?tab_501_417 c_unique)) (forall ((?alloc_500_418 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?p2_global_506_412)) (?v_5 (c_sort ?v_0 ?p1_global_505_413)) (?v_6 (c_sort ?v_0 ?anonymous_1PM_global_504_414)) (?v_2 (c_sort ?v_1 ?u1_502_416)) (?v_3 (c_sort ?v_1 ?tab_501_417))) (let ((?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2)))) (= (separation_anonymous_1_anonymous_0 (c_sort ?v_0 ?x_global_507_411) ?v_7 ?v_5 ?v_6 (c_sort ?v_0 ?anonymous_0PM_global_503_415) ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_500_418)) (and (not (= (base_addr ?v_2) ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (forall ((?index_7_499_419 Int)) (=> (and (<= 0 ?index_7_499_419) (< ?index_7_499_419 5)) (not (= (base_addr ?v_2) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?x_global_507_411) (c_sort ?v_1 (acc (c_sort ?v_0 ?anonymous_0PM_global_503_415) (c_sort ?v_1 (shift ?v_3 ?index_7_499_419))))))))))))))))))))))))))) +(declare-fun separation_anonymous_1_anonymous_1 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?p2_global_513_420 c_unique)) (forall ((?p1_global_512_421 c_unique)) (forall ((?anonymous_1PM_global_511_422 c_unique)) (forall ((?u2_510_423 c_unique)) (forall ((?u1_509_424 c_unique)) (forall ((?alloc_508_425 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?p2_global_513_420)) (?v_5 (c_sort ?v_0 ?p1_global_512_421)) (?v_6 (c_sort ?v_0 ?anonymous_1PM_global_511_422)) (?v_2 (c_sort ?v_1 ?u2_510_423)) (?v_3 (c_sort ?v_1 ?u1_509_424))) (let ((?v_9 (base_addr ?v_2)) (?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2))) (?v_10 (c_sort ?v_1 (acc ?v_6 ?v_3)))) (= (separation_anonymous_1_anonymous_1 ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_508_425)) (and (not (= ?v_9 ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (and (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_10))))) (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_10)))))))))))))))))))) +(declare-fun separation_anonymous_1_int (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?p2_global_519_426 c_unique)) (forall ((?p1_global_518_427 c_unique)) (forall ((?anonymous_1PM_global_517_428 c_unique)) (forall ((?u1_516_429 c_unique)) (forall ((?v_515_430 c_unique)) (forall ((?alloc_514_431 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?p2_global_519_426)) (?v_5 (c_sort ?v_0 ?p1_global_518_427)) (?v_6 (c_sort ?v_0 ?anonymous_1PM_global_517_428)) (?v_2 (c_sort ?v_1 ?u1_516_429)) (?v_3 (c_sort ?v_1 ?v_515_430))) (let ((?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2)))) (= (separation_anonymous_1_int ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_514_431)) (and (not (= (base_addr ?v_2) ?v_4)) (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8))))))))))))))))))) +(declare-fun separation_anonymous_1_s1 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?u_global_528_432 c_unique)) (forall ((?t_global_527_433 c_unique)) (forall ((?s1PM_global_526_434 c_unique)) (forall ((?p2_global_525_435 c_unique)) (forall ((?p1_global_524_436 c_unique)) (forall ((?anonymous_1PM_global_523_437 c_unique)) (forall ((?u1_522_438 c_unique)) (forall ((?s_521_439 c_unique)) (forall ((?alloc_520_440 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_12 (c_sort ?v_0 ?u_global_528_432)) (?v_10 (c_sort ?v_0 ?t_global_527_433)) (?v_11 (c_sort ?v_0 ?s1PM_global_526_434)) (?v_7 (c_sort ?v_0 ?p2_global_525_435)) (?v_5 (c_sort ?v_0 ?p1_global_524_436)) (?v_6 (c_sort ?v_0 ?anonymous_1PM_global_523_437)) (?v_2 (c_sort ?v_1 ?u1_522_438)) (?v_3 (c_sort ?v_1 ?s_521_439))) (let ((?v_9 (base_addr ?v_2)) (?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2))) (?v_13 (c_sort ?v_1 (acc ?v_11 ?v_3)))) (= (separation_anonymous_1_s1 ?v_12 ?v_10 ?v_11 ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_520_440)) (and (not (= ?v_9 ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (and (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_10 ?v_13))))) (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_12 ?v_13))))))))))))))))))))))) +(declare-fun separation_anonymous_2_anonymous_0 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?x_global_537_441 c_unique)) (forall ((?anonymous_2_p2_global_536_442 c_unique)) (forall ((?anonymous_2_p1_global_535_443 c_unique)) (forall ((?anonymous_2PM_global_534_444 c_unique)) (forall ((?anonymous_0PM_global_533_445 c_unique)) (forall ((?u3_532_446 c_unique)) (forall ((?tab_531_447 c_unique)) (forall ((?alloc_530_448 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?anonymous_2_p2_global_536_442)) (?v_5 (c_sort ?v_0 ?anonymous_2_p1_global_535_443)) (?v_6 (c_sort ?v_0 ?anonymous_2PM_global_534_444)) (?v_2 (c_sort ?v_1 ?u3_532_446)) (?v_3 (c_sort ?v_1 ?tab_531_447))) (let ((?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2)))) (= (separation_anonymous_2_anonymous_0 (c_sort ?v_0 ?x_global_537_441) ?v_7 ?v_5 ?v_6 (c_sort ?v_0 ?anonymous_0PM_global_533_445) ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_530_448)) (and (not (= (base_addr ?v_2) ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (forall ((?index_15_529_449 Int)) (=> (and (<= 0 ?index_15_529_449) (< ?index_15_529_449 5)) (not (= (base_addr ?v_2) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?x_global_537_441) (c_sort ?v_1 (acc (c_sort ?v_0 ?anonymous_0PM_global_533_445) (c_sort ?v_1 (shift ?v_3 ?index_15_529_449))))))))))))))))))))))))))) +(declare-fun separation_anonymous_2_anonymous_1 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?p2_global_546_450 c_unique)) (forall ((?p1_global_545_451 c_unique)) (forall ((?anonymous_2_p2_global_544_452 c_unique)) (forall ((?anonymous_2_p1_global_543_453 c_unique)) (forall ((?anonymous_2PM_global_542_454 c_unique)) (forall ((?anonymous_1PM_global_541_455 c_unique)) (forall ((?u3_540_456 c_unique)) (forall ((?u1_539_457 c_unique)) (forall ((?alloc_538_458 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_12 (c_sort ?v_0 ?p2_global_546_450)) (?v_10 (c_sort ?v_0 ?p1_global_545_451)) (?v_7 (c_sort ?v_0 ?anonymous_2_p2_global_544_452)) (?v_5 (c_sort ?v_0 ?anonymous_2_p1_global_543_453)) (?v_6 (c_sort ?v_0 ?anonymous_2PM_global_542_454)) (?v_11 (c_sort ?v_0 ?anonymous_1PM_global_541_455)) (?v_2 (c_sort ?v_1 ?u3_540_456)) (?v_3 (c_sort ?v_1 ?u1_539_457))) (let ((?v_9 (base_addr ?v_2)) (?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2))) (?v_13 (c_sort ?v_1 (acc ?v_11 ?v_3)))) (= (separation_anonymous_2_anonymous_1 ?v_12 ?v_10 ?v_7 ?v_5 ?v_6 ?v_11 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_538_458)) (and (not (= ?v_9 ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (and (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_10 ?v_13))))) (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_12 ?v_13))))))))))))))))))))))) +(declare-fun separation_anonymous_2_anonymous_2 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?anonymous_2_p2_global_552_459 c_unique)) (forall ((?anonymous_2_p1_global_551_460 c_unique)) (forall ((?anonymous_2PM_global_550_461 c_unique)) (forall ((?u4_549_462 c_unique)) (forall ((?u3_548_463 c_unique)) (forall ((?alloc_547_464 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?anonymous_2_p2_global_552_459)) (?v_5 (c_sort ?v_0 ?anonymous_2_p1_global_551_460)) (?v_6 (c_sort ?v_0 ?anonymous_2PM_global_550_461)) (?v_2 (c_sort ?v_1 ?u4_549_462)) (?v_3 (c_sort ?v_1 ?u3_548_463))) (let ((?v_9 (base_addr ?v_2)) (?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2))) (?v_10 (c_sort ?v_1 (acc ?v_6 ?v_3)))) (= (separation_anonymous_2_anonymous_2 ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_547_464)) (and (not (= ?v_9 ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (and (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_10))))) (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_10)))))))))))))))))))) +(declare-fun separation_anonymous_2_int (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?anonymous_2_p2_global_558_465 c_unique)) (forall ((?anonymous_2_p1_global_557_466 c_unique)) (forall ((?anonymous_2PM_global_556_467 c_unique)) (forall ((?u3_555_468 c_unique)) (forall ((?v_554_469 c_unique)) (forall ((?alloc_553_470 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?anonymous_2_p2_global_558_465)) (?v_5 (c_sort ?v_0 ?anonymous_2_p1_global_557_466)) (?v_6 (c_sort ?v_0 ?anonymous_2PM_global_556_467)) (?v_2 (c_sort ?v_1 ?u3_555_468)) (?v_3 (c_sort ?v_1 ?v_554_469))) (let ((?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2)))) (= (separation_anonymous_2_int ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_553_470)) (and (not (= (base_addr ?v_2) ?v_4)) (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8))))))))))))))))))) +(declare-fun separation_anonymous_2_s1 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?u_global_567_471 c_unique)) (forall ((?t_global_566_472 c_unique)) (forall ((?s1PM_global_565_473 c_unique)) (forall ((?anonymous_2_p2_global_564_474 c_unique)) (forall ((?anonymous_2_p1_global_563_475 c_unique)) (forall ((?anonymous_2PM_global_562_476 c_unique)) (forall ((?u3_561_477 c_unique)) (forall ((?s_560_478 c_unique)) (forall ((?alloc_559_479 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_12 (c_sort ?v_0 ?u_global_567_471)) (?v_10 (c_sort ?v_0 ?t_global_566_472)) (?v_11 (c_sort ?v_0 ?s1PM_global_565_473)) (?v_7 (c_sort ?v_0 ?anonymous_2_p2_global_564_474)) (?v_5 (c_sort ?v_0 ?anonymous_2_p1_global_563_475)) (?v_6 (c_sort ?v_0 ?anonymous_2PM_global_562_476)) (?v_2 (c_sort ?v_1 ?u3_561_477)) (?v_3 (c_sort ?v_1 ?s_560_478))) (let ((?v_9 (base_addr ?v_2)) (?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2))) (?v_13 (c_sort ?v_1 (acc ?v_11 ?v_3)))) (= (separation_anonymous_2_s1 ?v_12 ?v_10 ?v_11 ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_559_479)) (and (not (= ?v_9 ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (and (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_10 ?v_13))))) (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_12 ?v_13))))))))))))))))))))))) +(declare-fun separation_int_s1 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?u_global_573_480 c_unique)) (forall ((?t_global_572_481 c_unique)) (forall ((?s1PM_global_571_482 c_unique)) (forall ((?v_570_483 c_unique)) (forall ((?s_569_484 c_unique)) (forall ((?alloc_568_485 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?u_global_573_480)) (?v_5 (c_sort ?v_0 ?t_global_572_481)) (?v_6 (c_sort ?v_0 ?s1PM_global_571_482)) (?v_2 (c_sort ?v_1 ?v_570_483)) (?v_3 (c_sort ?v_1 ?s_569_484))) (let ((?v_4 (base_addr ?v_2)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_3)))) (= (separation_int_s1 ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_568_485)) (and (not (= ?v_4 (base_addr ?v_3))) (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8))))))))))))))))))) +(declare-fun separation_s1_s1 (c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?u_global_579_486 c_unique)) (forall ((?t_global_578_487 c_unique)) (forall ((?s1PM_global_577_488 c_unique)) (forall ((?ss_576_489 c_unique)) (forall ((?s_575_490 c_unique)) (forall ((?alloc_574_491 c_unique)) (let ((?v_1 (type_pointer type_global))) (let ((?v_0 (type_memory ?v_1 type_global))) (let ((?v_7 (c_sort ?v_0 ?u_global_579_486)) (?v_5 (c_sort ?v_0 ?t_global_578_487)) (?v_6 (c_sort ?v_0 ?s1PM_global_577_488)) (?v_2 (c_sort ?v_1 ?ss_576_489)) (?v_3 (c_sort ?v_1 ?s_575_490))) (let ((?v_9 (base_addr ?v_2)) (?v_4 (base_addr ?v_3)) (?v_8 (c_sort ?v_1 (acc ?v_6 ?v_2))) (?v_10 (c_sort ?v_1 (acc ?v_6 ?v_3)))) (= (separation_s1_s1 ?v_7 ?v_5 ?v_6 ?v_2 ?v_3 (c_sort type_alloc_table ?alloc_574_491)) (and (not (= ?v_9 ?v_4)) (and (and (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_8))))) (not (= ?v_4 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_8)))))) (and (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_5 ?v_10))))) (not (= ?v_9 (base_addr (c_sort ?v_1 (acc ?v_7 ?v_10)))))))))))))))))))) +(assert (not (forall ((?alloc c_unique)) (forall ((?anonymous_2PM_global c_unique)) (forall ((?anonymous_2_p1_global c_unique)) (forall ((?anonymous_2_p2_global c_unique)) (forall ((?anonymous_2_v1_global c_unique)) (forall ((?anonymous_2_v2_global c_unique)) (forall ((?intM_global c_unique)) (forall ((?u3 c_unique)) (forall ((?u4 c_unique)) (forall ((?w1 c_unique)) (forall ((?w10 c_unique)) (forall ((?w2 c_unique)) (forall ((?w3 c_unique)) (forall ((?w4 c_unique)) (forall ((?w5 c_unique)) (forall ((?w6 c_unique)) (forall ((?w7 c_unique)) (forall ((?w8 c_unique)) (forall ((?w9 c_unique)) (let ((?v_0 (type_pointer type_global))) (let ((?v_2 (type_memory ?v_0 type_global)) (?v_3 (c_sort ?v_0 ?w3))) (let ((?v_5 (base_addr ?v_3)) (?v_8 (c_sort ?v_0 ?u4))) (let ((?v_1 (base_addr ?v_8)) (?v_6 (c_sort ?v_2 ?anonymous_2_p1_global)) (?v_7 (c_sort ?v_2 ?anonymous_2PM_global))) (let ((?v_4 (c_sort ?v_0 (acc ?v_7 ?v_3)))) (let ((?v_12 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_4)))) (?v_9 (c_sort ?v_2 ?anonymous_2_p2_global))) (let ((?v_13 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_4)))) (?v_10 (c_sort ?v_0 (acc ?v_7 ?v_8)))) (let ((?v_16 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_10)))) (?v_17 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_10)))) (?v_14 (c_sort ?v_0 ?u3))) (let ((?v_11 (base_addr ?v_14)) (?v_15 (c_sort ?v_0 (acc ?v_7 ?v_14)))) (let ((?v_18 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_15)))) (?v_19 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_15)))) (?v_20 (c_sort ?v_0 ?w1))) (let ((?v_22 (base_addr ?v_20)) (?v_21 (c_sort ?v_0 (acc ?v_7 ?v_20)))) (let ((?v_23 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_21)))) (?v_24 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_21)))) (?v_25 (c_sort type_alloc_table ?alloc)) (?v_54 (c_sort ?v_0 ?w9)) (?v_26 (c_sort ?v_0 ?w8)) (?v_27 (c_sort ?v_0 ?w7)) (?v_32 (c_sort ?v_0 ?w6)) (?v_37 (c_sort ?v_0 ?w5)) (?v_40 (c_sort ?v_0 ?w4)) (?v_43 (c_sort ?v_0 ?w2))) (let ((?v_30 (base_addr ?v_26)) (?v_28 (base_addr ?v_27)) (?v_29 (c_sort ?v_0 (acc ?v_7 ?v_26)))) (let ((?v_34 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_29)))) (?v_35 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_29)))) (?v_31 (c_sort ?v_0 (acc ?v_7 ?v_27)))) (let ((?v_59 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_31)))) (?v_60 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_31)))) (?v_33 (base_addr ?v_32)) (?v_36 (c_sort ?v_0 (acc ?v_7 ?v_32)))) (let ((?v_46 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_36)))) (?v_47 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_36)))) (?v_38 (base_addr ?v_37)) (?v_39 (c_sort ?v_0 (acc ?v_7 ?v_37)))) (let ((?v_48 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_39)))) (?v_49 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_39)))) (?v_41 (base_addr ?v_40)) (?v_42 (c_sort ?v_0 (acc ?v_7 ?v_40)))) (let ((?v_50 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_42)))) (?v_51 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_42)))) (?v_44 (base_addr ?v_43)) (?v_45 (c_sort ?v_0 (acc ?v_7 ?v_43)))) (let ((?v_52 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_45)))) (?v_53 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_45)))) (?v_66 (valid ?v_25 ?v_14)) (?v_61 (c_sort ?v_0 ?w10)) (?v_56 (base_addr ?v_54)) (?v_55 (c_sort ?v_0 (acc ?v_7 ?v_54)))) (let ((?v_57 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_55)))) (?v_58 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_55)))) (?v_63 (base_addr ?v_61)) (?v_62 (c_sort ?v_0 (acc ?v_7 ?v_61)))) (let ((?v_64 (base_addr (c_sort ?v_0 (acc ?v_6 ?v_62)))) (?v_65 (base_addr (c_sort ?v_0 (acc ?v_9 ?v_62))))) (=> (and (and (not (= ?v_5 ?v_1)) (and (and (not (= ?v_1 ?v_12)) (not (= ?v_1 ?v_13))) (and (not (= ?v_5 ?v_16)) (not (= ?v_5 ?v_17))))) (and (and (not (= ?v_5 ?v_11)) (and (and (not (= ?v_11 ?v_12)) (not (= ?v_11 ?v_13))) (and (not (= ?v_5 ?v_18)) (not (= ?v_5 ?v_19))))) (and (and (not (= ?v_1 ?v_11)) (and (and (not (= ?v_11 ?v_16)) (not (= ?v_11 ?v_17))) (and (not (= ?v_1 ?v_18)) (not (= ?v_1 ?v_19))))) (and (and (not (= ?v_22 ?v_1)) (and (and (not (= ?v_1 ?v_23)) (not (= ?v_1 ?v_24))) (and (not (= ?v_22 ?v_16)) (not (= ?v_22 ?v_17))))) (and (and (not (= ?v_22 ?v_11)) (and (and (not (= ?v_11 ?v_23)) (not (= ?v_11 ?v_24))) (and (not (= ?v_22 ?v_18)) (not (= ?v_22 ?v_19))))) (and (valid ?v_25 ?v_54) (and (valid ?v_25 ?v_26) (and (valid ?v_25 ?v_27) (and (valid ?v_25 ?v_32) (and (valid ?v_25 ?v_37) (and (valid ?v_25 ?v_40) (and (valid ?v_25 ?v_3) (and (valid ?v_25 ?v_43) (and (valid ?v_25 ?v_20) (and (and (not (= ?v_30 ?v_28)) (and (and (not (= ?v_28 ?v_34)) (not (= ?v_28 ?v_35))) (and (not (= ?v_30 ?v_59)) (not (= ?v_30 ?v_60))))) (and (and (not (= ?v_30 ?v_33)) (and (and (not (= ?v_33 ?v_34)) (not (= ?v_33 ?v_35))) (and (not (= ?v_30 ?v_46)) (not (= ?v_30 ?v_47))))) (and (and (not (= ?v_30 ?v_38)) (and (and (not (= ?v_38 ?v_34)) (not (= ?v_38 ?v_35))) (and (not (= ?v_30 ?v_48)) (not (= ?v_30 ?v_49))))) (and (and (not (= ?v_30 ?v_41)) (and (and (not (= ?v_41 ?v_34)) (not (= ?v_41 ?v_35))) (and (not (= ?v_30 ?v_50)) (not (= ?v_30 ?v_51))))) (and (and (not (= ?v_30 ?v_5)) (and (and (not (= ?v_5 ?v_34)) (not (= ?v_5 ?v_35))) (and (not (= ?v_30 ?v_12)) (not (= ?v_30 ?v_13))))) (and (and (not (= ?v_30 ?v_44)) (and (and (not (= ?v_44 ?v_34)) (not (= ?v_44 ?v_35))) (and (not (= ?v_30 ?v_52)) (not (= ?v_30 ?v_53))))) (and (and (not (= ?v_30 ?v_22)) (and (and (not (= ?v_22 ?v_34)) (not (= ?v_22 ?v_35))) (and (not (= ?v_30 ?v_23)) (not (= ?v_30 ?v_24))))) (and (valid ?v_25 ?v_8) (and ?v_66 (and (and (not (= ?v_33 ?v_38)) (and (and (not (= ?v_38 ?v_46)) (not (= ?v_38 ?v_47))) (and (not (= ?v_33 ?v_48)) (not (= ?v_33 ?v_49))))) (and (and (not (= ?v_33 ?v_41)) (and (and (not (= ?v_41 ?v_46)) (not (= ?v_41 ?v_47))) (and (not (= ?v_33 ?v_50)) (not (= ?v_33 ?v_51))))) (and (and (not (= ?v_33 ?v_5)) (and (and (not (= ?v_5 ?v_46)) (not (= ?v_5 ?v_47))) (and (not (= ?v_33 ?v_12)) (not (= ?v_33 ?v_13))))) (and (and (not (= ?v_33 ?v_44)) (and (and (not (= ?v_44 ?v_46)) (not (= ?v_44 ?v_47))) (and (not (= ?v_33 ?v_52)) (not (= ?v_33 ?v_53))))) (and (and (not (= ?v_33 ?v_22)) (and (and (not (= ?v_22 ?v_46)) (not (= ?v_22 ?v_47))) (and (not (= ?v_33 ?v_23)) (not (= ?v_33 ?v_24))))) (and (and (not (= ?v_30 ?v_1)) (and (and (not (= ?v_1 ?v_34)) (not (= ?v_1 ?v_35))) (and (not (= ?v_30 ?v_16)) (not (= ?v_30 ?v_17))))) (and (and (not (= ?v_30 ?v_11)) (and (and (not (= ?v_11 ?v_34)) (not (= ?v_11 ?v_35))) (and (not (= ?v_30 ?v_18)) (not (= ?v_30 ?v_19))))) (and (and (not (= ?v_41 ?v_5)) (and (and (not (= ?v_5 ?v_50)) (not (= ?v_5 ?v_51))) (and (not (= ?v_41 ?v_12)) (not (= ?v_41 ?v_13))))) (and (and (not (= ?v_41 ?v_44)) (and (and (not (= ?v_44 ?v_50)) (not (= ?v_44 ?v_51))) (and (not (= ?v_41 ?v_52)) (not (= ?v_41 ?v_53))))) (and (and (not (= ?v_41 ?v_22)) (and (and (not (= ?v_22 ?v_50)) (not (= ?v_22 ?v_51))) (and (not (= ?v_41 ?v_23)) (not (= ?v_41 ?v_24))))) (and (and (not (= ?v_33 ?v_1)) (and (and (not (= ?v_1 ?v_46)) (not (= ?v_1 ?v_47))) (and (not (= ?v_33 ?v_16)) (not (= ?v_33 ?v_17))))) (and (and (not (= ?v_33 ?v_11)) (and (and (not (= ?v_11 ?v_46)) (not (= ?v_11 ?v_47))) (and (not (= ?v_33 ?v_18)) (not (= ?v_33 ?v_19))))) (and (and (not (= ?v_44 ?v_22)) (and (and (not (= ?v_22 ?v_52)) (not (= ?v_22 ?v_53))) (and (not (= ?v_44 ?v_23)) (not (= ?v_44 ?v_24))))) (and (and (not (= ?v_41 ?v_1)) (and (and (not (= ?v_1 ?v_50)) (not (= ?v_1 ?v_51))) (and (not (= ?v_41 ?v_16)) (not (= ?v_41 ?v_17))))) (and (and (not (= ?v_41 ?v_11)) (and (and (not (= ?v_11 ?v_50)) (not (= ?v_11 ?v_51))) (and (not (= ?v_41 ?v_18)) (not (= ?v_41 ?v_19))))) (and (valid ?v_25 ?v_61) (and (and (not (= ?v_44 ?v_1)) (and (and (not (= ?v_1 ?v_52)) (not (= ?v_1 ?v_53))) (and (not (= ?v_44 ?v_16)) (not (= ?v_44 ?v_17))))) (and (and (not (= ?v_44 ?v_11)) (and (and (not (= ?v_11 ?v_52)) (not (= ?v_11 ?v_53))) (and (not (= ?v_44 ?v_18)) (not (= ?v_44 ?v_19))))) (and (and (not (= ?v_56 ?v_30)) (and (and (not (= ?v_30 ?v_57)) (not (= ?v_30 ?v_58))) (and (not (= ?v_56 ?v_34)) (not (= ?v_56 ?v_35))))) (and (and (not (= ?v_56 ?v_28)) (and (and (not (= ?v_28 ?v_57)) (not (= ?v_28 ?v_58))) (and (not (= ?v_56 ?v_59)) (not (= ?v_56 ?v_60))))) (and (and (not (= ?v_56 ?v_33)) (and (and (not (= ?v_33 ?v_57)) (not (= ?v_33 ?v_58))) (and (not (= ?v_56 ?v_46)) (not (= ?v_56 ?v_47))))) (and (and (not (= ?v_56 ?v_38)) (and (and (not (= ?v_38 ?v_57)) (not (= ?v_38 ?v_58))) (and (not (= ?v_56 ?v_48)) (not (= ?v_56 ?v_49))))) (and (and (not (= ?v_63 ?v_56)) (and (and (not (= ?v_56 ?v_64)) (not (= ?v_56 ?v_65))) (and (not (= ?v_63 ?v_57)) (not (= ?v_63 ?v_58))))) (and (and (not (= ?v_56 ?v_41)) (and (and (not (= ?v_41 ?v_57)) (not (= ?v_41 ?v_58))) (and (not (= ?v_56 ?v_50)) (not (= ?v_56 ?v_51))))) (and (and (not (= ?v_63 ?v_30)) (and (and (not (= ?v_30 ?v_64)) (not (= ?v_30 ?v_65))) (and (not (= ?v_63 ?v_34)) (not (= ?v_63 ?v_35))))) (and (and (not (= ?v_56 ?v_5)) (and (and (not (= ?v_5 ?v_57)) (not (= ?v_5 ?v_58))) (and (not (= ?v_56 ?v_12)) (not (= ?v_56 ?v_13))))) (and (and (not (= ?v_63 ?v_28)) (and (and (not (= ?v_28 ?v_64)) (not (= ?v_28 ?v_65))) (and (not (= ?v_63 ?v_59)) (not (= ?v_63 ?v_60))))) (and (and (not (= ?v_56 ?v_44)) (and (and (not (= ?v_44 ?v_57)) (not (= ?v_44 ?v_58))) (and (not (= ?v_56 ?v_52)) (not (= ?v_56 ?v_53))))) (and (and (not (= ?v_63 ?v_33)) (and (and (not (= ?v_33 ?v_64)) (not (= ?v_33 ?v_65))) (and (not (= ?v_63 ?v_46)) (not (= ?v_63 ?v_47))))) (and (and (not (= ?v_56 ?v_22)) (and (and (not (= ?v_22 ?v_57)) (not (= ?v_22 ?v_58))) (and (not (= ?v_56 ?v_23)) (not (= ?v_56 ?v_24))))) (and (and (not (= ?v_63 ?v_38)) (and (and (not (= ?v_38 ?v_64)) (not (= ?v_38 ?v_65))) (and (not (= ?v_63 ?v_48)) (not (= ?v_63 ?v_49))))) (and (and (not (= ?v_63 ?v_41)) (and (and (not (= ?v_41 ?v_64)) (not (= ?v_41 ?v_65))) (and (not (= ?v_63 ?v_50)) (not (= ?v_63 ?v_51))))) (and (and (not (= ?v_63 ?v_5)) (and (and (not (= ?v_5 ?v_64)) (not (= ?v_5 ?v_65))) (and (not (= ?v_63 ?v_12)) (not (= ?v_63 ?v_13))))) (and (and (not (= ?v_63 ?v_44)) (and (and (not (= ?v_44 ?v_64)) (not (= ?v_44 ?v_65))) (and (not (= ?v_63 ?v_52)) (not (= ?v_63 ?v_53))))) (and (and (not (= ?v_63 ?v_22)) (and (and (not (= ?v_22 ?v_64)) (not (= ?v_22 ?v_65))) (and (not (= ?v_63 ?v_23)) (not (= ?v_63 ?v_24))))) (and (and (not (= ?v_28 ?v_33)) (and (and (not (= ?v_33 ?v_59)) (not (= ?v_33 ?v_60))) (and (not (= ?v_28 ?v_46)) (not (= ?v_28 ?v_47))))) (and (and (not (= ?v_28 ?v_38)) (and (and (not (= ?v_38 ?v_59)) (not (= ?v_38 ?v_60))) (and (not (= ?v_28 ?v_48)) (not (= ?v_28 ?v_49))))) (and (and (not (= ?v_28 ?v_41)) (and (and (not (= ?v_41 ?v_59)) (not (= ?v_41 ?v_60))) (and (not (= ?v_28 ?v_50)) (not (= ?v_28 ?v_51))))) (and (and (not (= ?v_28 ?v_5)) (and (and (not (= ?v_5 ?v_59)) (not (= ?v_5 ?v_60))) (and (not (= ?v_28 ?v_12)) (not (= ?v_28 ?v_13))))) (and (and (not (= ?v_28 ?v_44)) (and (and (not (= ?v_44 ?v_59)) (not (= ?v_44 ?v_60))) (and (not (= ?v_28 ?v_52)) (not (= ?v_28 ?v_53))))) (and (and (not (= ?v_28 ?v_22)) (and (and (not (= ?v_22 ?v_59)) (not (= ?v_22 ?v_60))) (and (not (= ?v_28 ?v_23)) (not (= ?v_28 ?v_24))))) (and (and (not (= ?v_56 ?v_1)) (and (and (not (= ?v_1 ?v_57)) (not (= ?v_1 ?v_58))) (and (not (= ?v_56 ?v_16)) (not (= ?v_56 ?v_17))))) (and (and (not (= ?v_56 ?v_11)) (and (and (not (= ?v_11 ?v_57)) (not (= ?v_11 ?v_58))) (and (not (= ?v_56 ?v_18)) (not (= ?v_56 ?v_19))))) (and (and (not (= ?v_63 ?v_1)) (and (and (not (= ?v_1 ?v_64)) (not (= ?v_1 ?v_65))) (and (not (= ?v_63 ?v_16)) (not (= ?v_63 ?v_17))))) (and (and (not (= ?v_63 ?v_11)) (and (and (not (= ?v_11 ?v_64)) (not (= ?v_11 ?v_65))) (and (not (= ?v_63 ?v_18)) (not (= ?v_63 ?v_19))))) (and (and (not (= ?v_38 ?v_41)) (and (and (not (= ?v_41 ?v_48)) (not (= ?v_41 ?v_49))) (and (not (= ?v_38 ?v_50)) (not (= ?v_38 ?v_51))))) (and (and (not (= ?v_38 ?v_5)) (and (and (not (= ?v_5 ?v_48)) (not (= ?v_5 ?v_49))) (and (not (= ?v_38 ?v_12)) (not (= ?v_38 ?v_13))))) (and (and (not (= ?v_38 ?v_44)) (and (and (not (= ?v_44 ?v_48)) (not (= ?v_44 ?v_49))) (and (not (= ?v_38 ?v_52)) (not (= ?v_38 ?v_53))))) (and (and (not (= ?v_38 ?v_22)) (and (and (not (= ?v_22 ?v_48)) (not (= ?v_22 ?v_49))) (and (not (= ?v_38 ?v_23)) (not (= ?v_38 ?v_24))))) (and (and (not (= ?v_28 ?v_1)) (and (and (not (= ?v_1 ?v_59)) (not (= ?v_1 ?v_60))) (and (not (= ?v_28 ?v_16)) (not (= ?v_28 ?v_17))))) (and (and (not (= ?v_28 ?v_11)) (and (and (not (= ?v_11 ?v_59)) (not (= ?v_11 ?v_60))) (and (not (= ?v_28 ?v_18)) (not (= ?v_28 ?v_19))))) (and (and (not (= ?v_5 ?v_44)) (and (and (not (= ?v_44 ?v_12)) (not (= ?v_44 ?v_13))) (and (not (= ?v_5 ?v_52)) (not (= ?v_5 ?v_53))))) (and (and (not (= ?v_5 ?v_22)) (and (and (not (= ?v_22 ?v_12)) (not (= ?v_22 ?v_13))) (and (not (= ?v_5 ?v_23)) (not (= ?v_5 ?v_24))))) (and (and (not (= ?v_38 ?v_1)) (and (and (not (= ?v_1 ?v_48)) (not (= ?v_1 ?v_49))) (and (not (= ?v_38 ?v_16)) (not (= ?v_38 ?v_17))))) (and (and (not (= ?v_38 ?v_11)) (and (and (not (= ?v_11 ?v_48)) (not (= ?v_11 ?v_49))) (and (not (= ?v_38 ?v_18)) (not (= ?v_38 ?v_19))))) (and (separation1 ?v_6 ?v_9) (and (valid_acc ?v_9) (and (valid_acc ?v_6) (and (valid_acc_range ?v_9 5) (valid_acc_range ?v_6 5))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (=> ?v_66 (forall ((?anonymous_2_v1_global0 c_unique)) (forall ((?anonymous_2_v2_global0 c_unique)) (forall ((?intM_global0 c_unique)) (let ((?v_67 (type_memory c_int type_global)) (?v_69 (type_pset type_global))) (let ((?v_68 (c_sort ?v_69 (pset_singleton ?v_14)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global) (c_sort ?v_67 ?anonymous_2_v1_global0) ?v_68) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global) (c_sort ?v_67 ?anonymous_2_v2_global0) ?v_68)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global) (c_sort ?v_67 ?intM_global0) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_14)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_14)))) 0 4)))))) (=> (valid ?v_25 ?v_8) (forall ((?anonymous_2_v1_global1 c_unique)) (forall ((?anonymous_2_v2_global1 c_unique)) (forall ((?intM_global1 c_unique)) (let ((?v_70 (c_sort ?v_69 (pset_singleton ?v_8)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global0) (c_sort ?v_67 ?anonymous_2_v1_global1) ?v_70) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global0) (c_sort ?v_67 ?anonymous_2_v2_global1) ?v_70)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global0) (c_sort ?v_67 ?intM_global1) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_8)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_8)))) 0 4)))))) (=> (valid ?v_25 ?v_20) (forall ((?anonymous_2_v1_global2 c_unique)) (forall ((?anonymous_2_v2_global2 c_unique)) (forall ((?intM_global2 c_unique)) (let ((?v_71 (c_sort ?v_69 (pset_singleton ?v_20)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global1) (c_sort ?v_67 ?anonymous_2_v1_global2) ?v_71) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global1) (c_sort ?v_67 ?anonymous_2_v2_global2) ?v_71)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global1) (c_sort ?v_67 ?intM_global2) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_20)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_20)))) 0 4)))))) (=> (valid ?v_25 ?v_43) (forall ((?anonymous_2_v1_global3 c_unique)) (forall ((?anonymous_2_v2_global3 c_unique)) (forall ((?intM_global3 c_unique)) (let ((?v_72 (c_sort ?v_69 (pset_singleton ?v_43)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global2) (c_sort ?v_67 ?anonymous_2_v1_global3) ?v_72) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global2) (c_sort ?v_67 ?anonymous_2_v2_global3) ?v_72)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global2) (c_sort ?v_67 ?intM_global3) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_43)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_43)))) 0 4)))))) (=> (valid ?v_25 ?v_3) (forall ((?anonymous_2_v1_global4 c_unique)) (forall ((?anonymous_2_v2_global4 c_unique)) (forall ((?intM_global4 c_unique)) (let ((?v_73 (c_sort ?v_69 (pset_singleton ?v_3)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global3) (c_sort ?v_67 ?anonymous_2_v1_global4) ?v_73) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global3) (c_sort ?v_67 ?anonymous_2_v2_global4) ?v_73)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global3) (c_sort ?v_67 ?intM_global4) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_3)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_3)))) 0 4)))))) (=> (valid ?v_25 ?v_40) (forall ((?anonymous_2_v1_global5 c_unique)) (forall ((?anonymous_2_v2_global5 c_unique)) (forall ((?intM_global5 c_unique)) (let ((?v_74 (c_sort ?v_69 (pset_singleton ?v_40)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global4) (c_sort ?v_67 ?anonymous_2_v1_global5) ?v_74) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global4) (c_sort ?v_67 ?anonymous_2_v2_global5) ?v_74)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global4) (c_sort ?v_67 ?intM_global5) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_40)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_40)))) 0 4)))))) (=> (valid ?v_25 ?v_37) (forall ((?anonymous_2_v1_global6 c_unique)) (forall ((?anonymous_2_v2_global6 c_unique)) (forall ((?intM_global6 c_unique)) (let ((?v_75 (c_sort ?v_69 (pset_singleton ?v_37)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global5) (c_sort ?v_67 ?anonymous_2_v1_global6) ?v_75) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global5) (c_sort ?v_67 ?anonymous_2_v2_global6) ?v_75)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global5) (c_sort ?v_67 ?intM_global6) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_37)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_37)))) 0 4)))))) (=> (valid ?v_25 ?v_32) (forall ((?anonymous_2_v1_global7 c_unique)) (forall ((?anonymous_2_v2_global7 c_unique)) (forall ((?intM_global7 c_unique)) (let ((?v_76 (c_sort ?v_69 (pset_singleton ?v_32)))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global6) (c_sort ?v_67 ?anonymous_2_v1_global7) ?v_76) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global6) (c_sort ?v_67 ?anonymous_2_v2_global7) ?v_76)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global6) (c_sort ?v_67 ?intM_global7) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_32)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_32)))) 0 4)))))) (=> (valid ?v_25 ?v_27) (forall ((?anonymous_2_v1_global8 c_unique)) (forall ((?anonymous_2_v2_global8 c_unique)) (forall ((?intM_global8 c_unique)) (let ((?v_77 (c_sort ?v_69 (pset_singleton ?v_27))) (?v_78 (offset ?v_26))) (=> (and (and (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v1_global7) (c_sort ?v_67 ?anonymous_2_v1_global8) ?v_77) (not_assigns ?v_25 (c_sort ?v_67 ?anonymous_2_v2_global7) (c_sort ?v_67 ?anonymous_2_v2_global8) ?v_77)) (not_assigns ?v_25 (c_sort ?v_67 ?intM_global7) (c_sort ?v_67 ?intM_global8) (c_sort ?v_69 (pset_union (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_9 ?v_27)))) 0 4)) (c_sort ?v_69 (pset_range (c_sort ?v_69 (pset_singleton (c_sort ?v_0 (acc ?v_6 ?v_27)))) 0 4)))))) (and (<= 0 ?v_78) (< ?v_78 (block_length ?v_25 ?v_26))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/quaternion_ds1_symm_0428.fof.smt2 b/test/regress/regress1/quantifiers/quaternion_ds1_symm_0428.fof.smt2 new file mode 100644 index 000000000..e7be953ce --- /dev/null +++ b/test/regress/regress1/quantifiers/quaternion_ds1_symm_0428.fof.smt2 @@ -0,0 +1,49 @@ +; COMMAND-LINE: --full-saturate-quant --multi-trigger-cache +; EXPECT: unsat +(set-logic AUFLIRA) +(set-info :status unsat) +(declare-fun def () Real) +(declare-fun h_ds1_filter () (Array Int (Array Int Real))) +(declare-fun id_ds1_filter () (Array Int (Array Int Real))) +(declare-fun pminus_ds1_filter () (Array Int (Array Int Real))) +(declare-fun pv5 () Int) +(declare-fun q_ds1_filter () (Array Int (Array Int Real))) +(declare-fun r_ds1_filter () (Array Int (Array Int Real))) +(declare-fun use () Real) +(declare-fun uniform_int_rnd (Int Int) Int) +(declare-fun abs_ (Real) Real) +(declare-fun log (Real) Real) +(declare-fun exp (Real) Real) +(declare-fun cos (Real) Real) +(declare-fun sin (Real) Real) +(declare-fun sqrt (Real) Real) +(declare-fun divide (Real Real) Real) +(declare-fun cond (Int Real Real) Real) +(declare-fun tptp_term_equal (Real Real) Int) +(declare-fun tptp_term_equals (Real Real) Int) +(declare-fun tptp_term_and (Real Real) Int) +(declare-fun sum (Int Int Real) Real) +(declare-fun dim (Int Int) Int) +(declare-fun trans ((Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun inv ((Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_mmul ((Array Int (Array Int Real)) (Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_madd ((Array Int (Array Int Real)) (Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_msub ((Array Int (Array Int Real)) (Array Int (Array Int Real))) (Array Int (Array Int Real))) +(declare-fun tptp_const_array1 (Int Real) (Array Int Real)) +(declare-fun tptp_const_array2 (Int Int Real) (Array Int (Array Int Real))) +(assert (forall ((?X_0 Int) (?C_1 Int)) (=> (>= ?X_0 0) (<= (uniform_int_rnd ?C_1 ?X_0) ?X_0)))) +(assert (forall ((?X_2 Int) (?C_3 Int)) (=> (>= ?X_2 0) (>= (uniform_int_rnd ?C_3 ?X_2) 0)))) +(assert (forall ((?I_4 Int) (?L_5 Int) (?U_6 Int) (?Val_7 Real)) (=> (and (<= ?L_5 ?I_4) (<= ?I_4 ?U_6)) (= (select (tptp_const_array1 (dim ?L_5 ?U_6) ?Val_7) ?I_4) ?Val_7)))) +(assert (forall ((?I_8 Int) (?L1_9 Int) (?U1_10 Int) (?J_11 Int) (?L2_12 Int) (?U2_13 Int) (?Val_14 Real)) (=> (and (and (and (<= ?L1_9 ?I_8) (<= ?I_8 ?U1_10)) (<= ?L2_12 ?J_11)) (<= ?J_11 ?U2_13)) (= (select (select (tptp_const_array2 (dim ?L1_9 ?U1_10) (dim ?L2_12 ?U2_13) ?Val_14) ?I_8) ?J_11) ?Val_14)))) +(assert (forall ((?I0_15 Int) (?J0_16 Int) (?A_17 (Array Int (Array Int Real))) (?B_18 (Array Int (Array Int Real))) (?N_19 Int)) (let ((?v_0 (tptp_mmul ?A_17 (tptp_mmul ?B_18 (trans ?A_17))))) (=> (and (and (and (and (>= ?I0_15 0) (<= ?I0_15 ?N_19)) (>= ?J0_16 0)) (<= ?J0_16 ?N_19)) (= (select (select ?B_18 ?I0_15) ?J0_16) (select (select ?B_18 ?J0_16) ?I0_15))) (= (select (select ?v_0 ?I0_15) ?J0_16) (select (select ?v_0 ?J0_16) ?I0_15)))))) +(assert (forall ((?I0_20 Int) (?J0_21 Int) (?I_22 Int) (?J_23 Int) (?A_24 (Array Int (Array Int Real))) (?B_25 (Array Int (Array Int Real))) (?N_26 Int) (?M_27 Int)) (let ((?v_0 (tptp_mmul ?A_24 (tptp_mmul ?B_25 (trans ?A_24))))) (=> (and (and (and (and (and (and (and (and (>= ?I0_20 0) (<= ?I0_20 ?N_26)) (>= ?J0_21 0)) (<= ?J0_21 ?N_26)) (>= ?I_22 0)) (<= ?I_22 ?M_27)) (>= ?J_23 0)) (<= ?J_23 ?M_27)) (= (select (select ?B_25 ?I_22) ?J_23) (select (select ?B_25 ?J_23) ?I_22))) (= (select (select ?v_0 ?I0_20) ?J0_21) (select (select ?v_0 ?J0_21) ?I0_20)))))) +(assert (forall ((?I_28 Int) (?J_29 Int) (?A_30 (Array Int (Array Int Real))) (?B_31 (Array Int (Array Int Real))) (?N_32 Int)) (let ((?v_0 (tptp_madd ?A_30 ?B_31))) (=> (and (and (and (and (and (>= ?I_28 0) (<= ?I_28 ?N_32)) (>= ?J_29 0)) (<= ?J_29 ?N_32)) (= (select (select ?A_30 ?I_28) ?J_29) (select (select ?A_30 ?J_29) ?I_28))) (= (select (select ?B_31 ?I_28) ?J_29) (select (select ?B_31 ?J_29) ?I_28))) (= (select (select ?v_0 ?I_28) ?J_29) (select (select ?v_0 ?J_29) ?I_28)))))) +(assert (forall ((?I_33 Int) (?J_34 Int) (?A_35 (Array Int (Array Int Real))) (?B_36 (Array Int (Array Int Real))) (?N_37 Int)) (let ((?v_0 (tptp_msub ?A_35 ?B_36))) (=> (and (and (and (and (and (>= ?I_33 0) (<= ?I_33 ?N_37)) (>= ?J_34 0)) (<= ?J_34 ?N_37)) (= (select (select ?A_35 ?I_33) ?J_34) (select (select ?A_35 ?J_34) ?I_33))) (= (select (select ?B_36 ?I_33) ?J_34) (select (select ?B_36 ?J_34) ?I_33))) (= (select (select ?v_0 ?I_33) ?J_34) (select (select ?v_0 ?J_34) ?I_33)))))) +(assert (forall ((?I_38 Int) (?J_39 Int) (?A_40 (Array Int (Array Int Real))) (?N_41 Int)) (let ((?v_0 (trans ?A_40))) (=> (and (and (and (and (>= ?I_38 0) (<= ?I_38 ?N_41)) (>= ?J_39 0)) (<= ?J_39 ?N_41)) (= (select (select ?A_40 ?I_38) ?J_39) (select (select ?A_40 ?J_39) ?I_38))) (= (select (select ?v_0 ?I_38) ?J_39) (select (select ?v_0 ?J_39) ?I_38)))))) +(assert (forall ((?I_42 Int) (?J_43 Int) (?A_44 (Array Int (Array Int Real))) (?N_45 Int)) (let ((?v_0 (inv ?A_44))) (=> (and (and (and (and (>= ?I_42 0) (<= ?I_42 ?N_45)) (>= ?J_43 0)) (<= ?J_43 ?N_45)) (= (select (select ?A_44 ?I_42) ?J_43) (select (select ?A_44 ?J_43) ?I_42))) (= (select (select ?v_0 ?I_42) ?J_43) (select (select ?v_0 ?J_43) ?I_42)))))) +(assert (forall ((?I0_46 Int) (?J0_47 Int) (?I_48 Int) (?J_49 Int) (?A_50 (Array Int (Array Int Real))) (?B_51 (Array Int (Array Int Real))) (?C_52 (Array Int (Array Int Real))) (?D_53 (Array Int (Array Int Real))) (?E_54 (Array Int (Array Int Real))) (?F_55 (Array Int (Array Int Real))) (?N_56 Int) (?M_57 Int)) (let ((?v_0 (tptp_madd ?A_50 (tptp_mmul ?B_51 (tptp_mmul (tptp_madd (tptp_mmul ?C_52 (tptp_mmul ?D_53 (trans ?C_52))) (tptp_mmul ?E_54 (tptp_mmul ?F_55 (trans ?E_54)))) (trans ?B_51)))))) (=> (and (and (and (and (and (and (and (and (and (and (>= ?I0_46 0) (<= ?I0_46 ?N_56)) (>= ?J0_47 0)) (<= ?J0_47 ?N_56)) (>= ?I_48 0)) (<= ?I_48 ?M_57)) (>= ?J_49 0)) (<= ?J_49 ?M_57)) (= (select (select ?D_53 ?I_48) ?J_49) (select (select ?D_53 ?J_49) ?I_48))) (= (select (select ?A_50 ?I0_46) ?J0_47) (select (select ?A_50 ?J0_47) ?I0_46))) (= (select (select ?F_55 ?I0_46) ?J0_47) (select (select ?F_55 ?J0_47) ?I0_46))) (= (select (select ?v_0 ?I0_46) ?J0_47) (select (select ?v_0 ?J0_47) ?I0_46)))))) +(assert (forall ((?Body_58 Real)) (= (sum 0 (- 1) ?Body_58) 0.0))) +(assert (not (= def use))) +(assert (not (=> (and (and (and (and (and (and (>= pv5 0) (<= pv5 998)) (> pv5 0)) (forall ((?A_59 Int) (?B_60 Int)) (=> (and (and (and (>= ?A_59 0) (>= ?B_60 0)) (<= ?A_59 5)) (<= ?B_60 5)) (= (select (select q_ds1_filter ?A_59) ?B_60) (select (select q_ds1_filter ?B_60) ?A_59))))) (forall ((?C_61 Int) (?D_62 Int)) (=> (and (and (and (>= ?C_61 0) (>= ?D_62 0)) (<= ?C_61 2)) (<= ?D_62 2)) (= (select (select r_ds1_filter ?C_61) ?D_62) (select (select r_ds1_filter ?D_62) ?C_61))))) (forall ((?E_63 Int) (?F_64 Int)) (=> (and (and (and (>= ?E_63 0) (>= ?F_64 0)) (<= ?E_63 5)) (<= ?F_64 5)) (= (select (select pminus_ds1_filter ?E_63) ?F_64) (select (select pminus_ds1_filter ?F_64) ?E_63))))) (forall ((?G_65 Int)) (=> (and (>= ?G_65 0) (<= ?G_65 5)) (forall ((?H_66 Int)) (=> (and (>= ?H_66 0) (<= ?H_66 5)) (= (select (select id_ds1_filter ?G_65) ?H_66) (select (select id_ds1_filter ?H_66) ?G_65))))))) (forall ((?I_67 Int) (?J_68 Int)) (let ((?v_0 (trans h_ds1_filter))) (let ((?v_1 (tptp_mmul pminus_ds1_filter (tptp_mmul ?v_0 (inv (tptp_madd r_ds1_filter (tptp_mmul h_ds1_filter (tptp_mmul pminus_ds1_filter ?v_0)))))))) (let ((?v_2 (tptp_mmul ?v_1 (tptp_mmul r_ds1_filter (trans ?v_1))))) (=> (and (and (and (>= ?I_67 0) (>= ?J_68 0)) (<= ?I_67 5)) (<= ?J_68 5)) (= (select (select ?v_2 ?I_67) ?J_68) (select (select ?v_2 ?J_68) ?I_67)))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/rew-to-0211-dd.smt2 b/test/regress/regress1/quantifiers/rew-to-0211-dd.smt2 new file mode 100644 index 000000000..ec49231e3 --- /dev/null +++ b/test/regress/regress1/quantifiers/rew-to-0211-dd.smt2 @@ -0,0 +1,259 @@ +(set-logic UFLIA) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun boolIff (Int Int) Int) +(declare-fun PeerGroupPlaceholder_ () Int) +(declare-fun intGreater (Int Int) Int) +(declare-fun IfThenElse_ (Int Int Int) Int) +(declare-fun System.IConvertible () Int) +(declare-fun CONCVARSYM (Int) Int) +(declare-fun throwException_in () Int) +(declare-fun SharingMode_Unshared_ () Int) +(declare-fun System.Reflection.IReflect () Int) +(declare-fun result_0_ () Int) +(declare-fun block3502_2_block3553_correct () Int) +(declare-fun int_m2147483648 () Int) +(declare-fun local0_0 () Int) +(declare-fun System.Int32 () Int) +(declare-fun local0_1 () Int) +(declare-fun block3536_2_block3553_correct () Int) +(declare-fun block3553_correct () Int) +(declare-fun intAtMost (Int Int) Int) +(declare-fun multiply (Int Int) Int) +(declare-fun Is_ (Int Int) Int) +(declare-fun Smt.true () Int) +(declare-fun ElementType_ (Int) Int) +(declare-fun divide (Int Int) Int) +(declare-fun int_m9223372036854775808 () Int) +(declare-fun divides (Int Int) Int) +(declare-fun stack0b_0 () Int) +(declare-fun select1 (Int Int) Int) +(declare-fun stack0b_1 () Int) +(declare-fun store1 (Int Int Int) Int) +(declare-fun select2 (Int Int Int) Int) +(declare-fun nullObject () Int) +(declare-fun store2 (Int Int Int Int) Int) +(declare-fun false3451to3468_correct () Int) +(declare-fun modulo (Int Int) Int) +(declare-fun System.IComparable () Int) +(declare-fun ownerRef_ () Int) +(declare-fun StructSet_ (Int Int Int) Int) +(declare-fun AsDirectSubClass (Int Int) Int) +(declare-fun System.IEquatable_1...System.String () Int) +(declare-fun System.Boolean () Int) +(declare-fun shl_ (Int Int) Int) +(declare-fun DimLength_ (Int Int) Int) +(declare-fun anyEqual (Int Int) Int) +(declare-fun System.Array () Int) +(declare-fun block3451_correct () Int) +(declare-fun System.Collections.Generic.IEnumerable_1...System.Char () Int) +(declare-fun System.Reflection.ICustomAttributeProvider () Int) +(declare-fun SharingMode_LockProtected_ () Int) +(declare-fun IsMemberlessType_ (Int) Int) +(declare-fun PartOfLine () Int) +(declare-fun System.UInt16 () Int) +(declare-fun false3434to3451_correct () Int) +(declare-fun ClassRepr (Int) Int) +(declare-fun System.Runtime.InteropServices._Type () Int) +(declare-fun boolNot (Int) Int) +(declare-fun Microsoft.Contracts.ICheckedException () Int) +(declare-fun System.Exception () Int) +(declare-fun System.Runtime.InteropServices._MemberInfo () Int) +(declare-fun boolAnd (Int Int) Int) +(declare-fun boolImplies (Int Int) Int) +(declare-fun Unbox (Int) Int) +(declare-fun intAtLeast (Int Int) Int) +(declare-fun ownerFrame_ () Int) +(declare-fun int_4294967295 () Int) +(declare-fun IsAllocated (Int Int) Int) +(declare-fun TypeName (Int) Int) +(declare-fun AsPeerField (Int) Int) +(declare-fun int_9223372036854775807 () Int) +(declare-fun AsRepField (Int Int) Int) +(declare-fun System.Reflection.MemberInfo () Int) +(declare-fun ArrayCategoryValue_ () Int) +(declare-fun is (Int Int) Int) +(declare-fun Microsoft.Contracts.GuardException () Int) +(declare-fun InRange (Int Int) Bool) +(declare-fun AsOwner (Int Int) Int) +(declare-fun System.Int64 () Int) +(declare-fun System.Runtime.InteropServices._Exception () Int) +(declare-fun or_ (Int Int) Int) +(declare-fun As_ (Int Int) Int) +(declare-fun exposeVersion_ () Int) +(declare-fun true3434to3536_correct () Int) +(declare-fun System.Type () Int) +(declare-fun intLess (Int Int) Int) +(declare-fun AsImmutable_ (Int) Int) +(declare-fun NonNullFieldsAreInitialized_ () Int) +(declare-fun block3417_correct () Int) +(declare-fun LBound_ (Int Int) Int) +(declare-fun System.Object () Int) +(declare-fun System.UInt32 () Int) +(declare-fun localinv_ () Int) +(declare-fun inv_ () Int) +(declare-fun Interval () Int) +(declare-fun stack50000o_0 () Int) +(declare-fun stack50000o_1 () Int) +(declare-fun Heap_0_ () Int) +(declare-fun entry_correct () Int) +(declare-fun FirstConsistentOwner_ () Int) +(declare-fun UnboxedType (Int) Int) +(declare-fun AsRefField (Int Int) Int) +(declare-fun System.Byte () Int) +(declare-fun this () Int) +(declare-fun stack1o_0 () Int) +(declare-fun int_2147483647 () Int) +(declare-fun ArrayCategoryRef_ () Int) +(declare-fun Interval.a () Int) +(declare-fun Interval.b () Int) +(declare-fun stack1i_0 () Int) +(declare-fun Heap_ () Int) +(declare-fun Length_ (Int) Int) +(declare-fun System.Runtime.Serialization.ISerializable () Int) +(declare-fun AsNonNullRefField (Int Int) Int) +(declare-fun IsHeap (Int) Int) +(declare-fun Heap_1_ () Int) +(declare-fun UBound_ (Int Int) Int) +(declare-fun Cell () Int) +(declare-fun System.String () Int) +(declare-fun System.String.IsInterned_System.String_notnull_ (Int) Int) +(declare-fun Rank_ (Int) Int) +(declare-fun UnknownRef_ () Int) +(declare-fun RefArraySet (Int Int Int) Int) +(declare-fun ValueArraySet (Int Int Int) Int) +(declare-fun stack50000o () Int) +(declare-fun boolOr (Int Int) Int) +(declare-fun sharingMode_ () Int) +(declare-fun subtypes (Int Int) Bool) +(declare-fun System.IComparable_1...System.String () Int) +(declare-fun System.String.Equals_System.String_System.String_ (Int Int) Int) +(declare-fun block3434_correct () Int) +(declare-fun anyNeq (Int Int) Int) +(declare-fun IsStaticField (Int) Int) +(declare-fun SS_Display.Return.Local_0 () Int) +(declare-fun IsNotNull_ (Int Int) Int) +(declare-fun typeof_ (Int) Int) +(declare-fun ArrayCategoryNonNullRef_ () Int) +(declare-fun RefArrayGet (Int Int) Int) +(declare-fun ValueArrayGet (Int Int) Int) +(declare-fun TypeObject (Int) Int) +(declare-fun and_ (Int Int) Int) +(declare-fun BoxTester (Int Int) Int) +(declare-fun Microsoft.Contracts.ObjectInvariantException () Int) +(declare-fun block3468_correct () Int) +(declare-fun IsValueType_ (Int) Int) +(declare-fun Heap_2_ () Int) +(declare-fun AsRangeField (Int Int) Int) +(declare-fun System.SByte () Int) +(declare-fun BeingConstructed_ () Int) +(declare-fun block3502_correct () Int) +(declare-fun FieldDependsOnFCO_ (Int Int Int) Int) +(declare-fun NonNullRefArray (Int Int) Int) +(declare-fun RefArray (Int Int) Int) +(declare-fun ArrayCategory_ (Int) Int) +(declare-fun stack0b () Int) +(declare-fun Cell.Value () Int) +(declare-fun AsPureObject_ (Int) Int) +(declare-fun System.String.Equals_System.String_ (Int Int) Int) +(declare-fun System.Int16 () Int) +(declare-fun block3536_correct () Int) +(declare-fun AsMutable_ (Int) Int) +(declare-fun System.Char () Int) +(declare-fun System.UInt64 () Int) +(declare-fun StructGet_ (Int Int) Int) +(declare-fun OneClassDown (Int Int) Int) +(declare-fun ArrayIndex (Int Int Int Int) Int) +(declare-fun stack0o_0 () Int) +(declare-fun Box (Int Int) Int) +(declare-fun stack0o_1 () Int) +(declare-fun int_18446744073709551615 () Int) +(declare-fun shr_ (Int Int) Int) +(declare-fun stack0i_0 () Int) +(declare-fun block3553_2_GeneratedUnifiedExit_correct () Int) +(declare-fun System.ICloneable () Int) +(declare-fun IsDirectlyModifiableField (Int) Int) +(declare-fun StringLength_ (Int) Int) +(declare-fun allocated_ () Int) +(declare-fun BaseClass_ (Int) Int) +(declare-fun ValueArray (Int Int) Int) +(declare-fun Smt.false () Int) +(declare-fun true3451to3502_correct () Int) +(declare-fun IsImmutable_ (Int) Int) +(declare-fun elements_ () Int) +(declare-fun DeclType (Int) Int) +(declare-fun System.Collections.IEnumerable () Int) +(declare-fun ReallyLastGeneratedExit_correct () Int) +(assert (forall ((?o Int) (?T Int)) (! (= (= (IsNotNull_ ?o ?T) Smt.true) (and (not (= ?o nullObject)) (= (Is_ ?o ?T) Smt.true))) :pattern ((IsNotNull_ ?o ?T)) ))) +(assert (forall ((?h Int) (?o Int) (?f Int) (?T Int)) (! (=> (and (= (IsHeap ?h) Smt.true) (not (= ?o nullObject)) (or (not (= ?o BeingConstructed_)) (= (= (select2 ?h BeingConstructed_ NonNullFieldsAreInitialized_) Smt.true) true))) (not (= (select2 ?h ?o (AsNonNullRefField ?f ?T)) nullObject))) :pattern ((select2 ?h ?o (AsNonNullRefField ?f ?T))) ))) +(assert (forall ((?o Int) (?T Int)) (! (=> (and (not (= ?o nullObject)) (not (= ?o BeingConstructed_)) (subtypes (typeof_ ?o) (AsImmutable_ ?T))) (forall ((?h Int)) (! (let ((?v_0 (typeof_ ?o))) (=> (= (IsHeap ?h) Smt.true) (and (= (select2 ?h ?o inv_) ?v_0) (= (select2 ?h ?o localinv_) ?v_0) (= (select2 ?h ?o ownerFrame_) PeerGroupPlaceholder_) (= (AsOwner ?o (select2 ?h ?o ownerRef_)) ?o) (forall ((?t Int)) (! (=> (= (AsOwner ?o (select2 ?h ?t ownerRef_)) ?o) (or (= ?t ?o) (not (= (select2 ?h ?t ownerFrame_) PeerGroupPlaceholder_)))) :pattern ((AsOwner ?o (select2 ?h ?t ownerRef_))) ))))) :pattern ((IsHeap ?h)) ))) :pattern ((subtypes (typeof_ ?o) (AsImmutable_ ?T))) ))) +(assert (= (IsValueType_ System.SByte) Smt.true)) +(assert (= (IsValueType_ System.Byte) Smt.true)) +(assert (= (IsValueType_ System.Int16) Smt.true)) +(assert (= (IsValueType_ System.UInt16) Smt.true)) +(assert (= (IsValueType_ System.Int32) Smt.true)) +(assert (= (IsValueType_ System.UInt32) Smt.true)) +(assert (= (IsValueType_ System.Int64) Smt.true)) +(assert (= (IsValueType_ System.UInt64) Smt.true)) +(assert (= (IsValueType_ System.Char) Smt.true)) +(assert (< int_m9223372036854775808 int_m2147483648)) +(assert (< int_m2147483648 (- 0 100000))) +(assert (< 100000 int_2147483647)) +(assert (< int_2147483647 int_4294967295)) +(assert (< int_4294967295 int_9223372036854775807)) +(assert (< int_9223372036854775807 int_18446744073709551615)) +(assert (not (= (IsStaticField Cell.Value) Smt.true))) +(assert (= (IsDirectlyModifiableField Cell.Value) Smt.true)) +(assert (= (DeclType Cell.Value) Cell)) +(assert (= (AsRangeField Cell.Value System.Int32) Cell.Value)) +(assert (not (= (IsStaticField Interval.a) Smt.true))) +(assert (= (IsDirectlyModifiableField Interval.a) Smt.true)) +(assert (= (AsRepField Interval.a Interval) Interval.a)) +(assert (= (DeclType Interval.a) Interval)) +(assert (= (AsNonNullRefField Interval.a Cell) Interval.a)) +(assert (not (= (IsStaticField Interval.b) Smt.true))) +(assert (= (IsDirectlyModifiableField Interval.b) Smt.true)) +(assert (= (AsRepField Interval.b Interval) Interval.b)) +(assert (= (DeclType Interval.b) Interval)) +(assert (= (AsNonNullRefField Interval.b Cell) Interval.b)) +(assert (subtypes Cell Cell)) +(assert (= (BaseClass_ Cell) System.Object)) +(assert (subtypes Cell (BaseClass_ Cell))) +(assert (= (AsDirectSubClass Cell (BaseClass_ Cell)) Cell)) +(assert (not (= (IsImmutable_ Cell) Smt.true))) +(assert (= (AsMutable_ Cell) Cell)) +(assert (subtypes System.Type System.Type)) +(assert (subtypes System.Reflection.MemberInfo System.Reflection.MemberInfo)) +(assert (= (BaseClass_ System.Reflection.MemberInfo) System.Object)) +(assert (subtypes System.Reflection.MemberInfo (BaseClass_ System.Reflection.MemberInfo))) +(assert (= (AsDirectSubClass System.Reflection.MemberInfo (BaseClass_ System.Reflection.MemberInfo)) System.Reflection.MemberInfo)) +(assert (= (IsImmutable_ System.Reflection.MemberInfo) Smt.true)) +(assert (= (AsImmutable_ System.Reflection.MemberInfo) System.Reflection.MemberInfo)) +(assert (subtypes System.Reflection.ICustomAttributeProvider System.Object)) +(assert (= (IsMemberlessType_ System.Reflection.ICustomAttributeProvider) Smt.true)) +(assert (subtypes System.Reflection.MemberInfo System.Reflection.ICustomAttributeProvider)) +(assert (subtypes System.Runtime.InteropServices._MemberInfo System.Object)) +(assert (= (IsMemberlessType_ System.Runtime.InteropServices._MemberInfo) Smt.true)) +(assert (subtypes System.Reflection.MemberInfo System.Runtime.InteropServices._MemberInfo)) +(assert (= (IsMemberlessType_ System.Reflection.MemberInfo) Smt.true)) +(assert (= (BaseClass_ System.Type) System.Reflection.MemberInfo)) +(assert (subtypes System.Type (BaseClass_ System.Type))) +(assert (= (AsDirectSubClass System.Type (BaseClass_ System.Type)) System.Type)) +(assert (= (IsImmutable_ System.Type) Smt.true)) +(assert (= (AsImmutable_ System.Type) System.Type)) +(assert (subtypes System.Runtime.InteropServices._Type System.Object)) +(assert (= (IsMemberlessType_ System.Runtime.InteropServices._Type) Smt.true)) +(assert (subtypes System.Type System.Runtime.InteropServices._Type)) +(assert (subtypes System.Reflection.IReflect System.Object)) +(assert (= (IsMemberlessType_ System.Reflection.IReflect) Smt.true)) +(assert (subtypes System.Type System.Reflection.IReflect)) +(assert (= (IsMemberlessType_ System.Type) Smt.true)) +(assert (subtypes PartOfLine PartOfLine)) +(assert (= (BaseClass_ PartOfLine) System.Object)) +(assert (subtypes PartOfLine (BaseClass_ PartOfLine))) +(assert (= (AsDirectSubClass PartOfLine (BaseClass_ PartOfLine)) PartOfLine)) +(assert (distinct Smt.false Smt.true)) +(assert (let ((?v_0 (select2 Heap_ this ownerFrame_)) (?v_1 (select2 Heap_ this ownerRef_)) (?v_2 (not (= this nullObject))) (?v_3 (not (= stack0o_0 nullObject))) (?v_4 (not (= stack1o_0 nullObject))) (?v_5 (forall ((?o_ Int)) (=> (and (not (= ?o_ nullObject)) (= (= (select2 Heap_ ?o_ allocated_) Smt.true) true)) (and (= (select2 Heap_ ?o_ ownerRef_) (select2 Heap_2_ ?o_ ownerRef_)) (= (select2 Heap_ ?o_ ownerFrame_) (select2 Heap_2_ ?o_ ownerFrame_)))))) (?v_12 (=> true true)) (?v_6 (= ReallyLastGeneratedExit_correct Smt.true)) (?v_7 (= block3553_2_GeneratedUnifiedExit_correct Smt.true)) (?v_15 (= block3553_correct Smt.true)) (?v_14 (= throwException_in Smt.true)) (?v_8 (not (= stack50000o_0 nullObject))) (?v_11 (typeof_ stack50000o_0)) (?v_9 (select2 Heap_1_ stack50000o_0 ownerFrame_)) (?v_10 (select2 Heap_1_ stack50000o_0 ownerRef_)) (?v_13 (= block3468_correct Smt.true)) (?v_19 (= false3451to3468_correct Smt.true))) (let ((?v_21 (=> true ?v_15)) (?v_16 (= block3502_2_block3553_correct Smt.true)) (?v_17 (= block3502_correct Smt.true)) (?v_18 (= true3451to3502_correct Smt.true)) (?v_20 (= block3451_correct Smt.true)) (?v_25 (= false3434to3451_correct Smt.true)) (?v_22 (= block3536_2_block3553_correct Smt.true)) (?v_23 (= block3536_correct Smt.true)) (?v_24 (= true3434to3536_correct Smt.true)) (?v_26 (= block3434_correct Smt.true)) (?v_27 (= block3417_correct Smt.true)) (?v_28 (= entry_correct Smt.true))) (not (=> (=> (=> true (=> (= (IsHeap Heap_) Smt.true) (=> true (=> (= BeingConstructed_ nullObject) (=> (and (or (= ?v_0 PeerGroupPlaceholder_) (not (subtypes (select2 Heap_ ?v_1 inv_) ?v_0)) (= (select2 Heap_ ?v_1 localinv_) (BaseClass_ ?v_0))) (forall ((?pc_ Int)) (let ((?v_29 (typeof_ ?pc_))) (=> (and (not (= ?pc_ nullObject)) (= (= (select2 Heap_ ?pc_ allocated_) Smt.true) true) (= (select2 Heap_ ?pc_ ownerRef_) ?v_1) (= (select2 Heap_ ?pc_ ownerFrame_) ?v_0)) (and (= (select2 Heap_ ?pc_ inv_) ?v_29) (= (select2 Heap_ ?pc_ localinv_) ?v_29)))))) (=> true (=> true (=> (= (IsNotNull_ this Interval) Smt.true) (=> (= (= (select2 Heap_ this allocated_) Smt.true) true) (=> true (=> (=> (=> true (=> true (=> true (=> (=> (=> true (=> true (and ?v_2 (=> ?v_2 (=> (= stack0o_0 (select2 Heap_ this Interval.a)) (and ?v_3 (=> ?v_3 (=> (= stack0i_0 (select2 Heap_ stack0o_0 Cell.Value)) (and ?v_2 (=> ?v_2 (=> (= stack1o_0 (select2 Heap_ this Interval.b)) (and ?v_4 (=> ?v_4 (=> (= stack1i_0 (select2 Heap_ stack1o_0 Cell.Value)) (=> true (=> (and (=> (=> true (=> true (=> true (=> (=> (=> true (=> (= SS_Display.Return.Local_0 local0_0) (=> (= result_0_ local0_0) (=> (= stack50000o_1 stack50000o) (=> (= stack0b_1 local0_0) (=> (= stack0o_1 stack0o_0) (=> (= local0_1 local0_0) (=> (= Heap_2_ Heap_) (=> (=> (=> true (and ?v_5 (=> ?v_5 ?v_12))) ?v_6) ?v_6))))))))) ?v_7) ?v_7)))) ?v_15) (=> (=> true (=> true (=> (> stack0i_0 stack1i_0) (=> true (=> (=> (=> true (=> true (=> true (=> (and (=> (=> true (=> true (=> ?v_14 (=> true (=> (=> (=> true (=> true (=> false (=> (and (= (= (select2 Heap_ stack50000o_0 allocated_) Smt.true) false) ?v_8 (= ?v_11 Microsoft.Contracts.ObjectInvariantException)) (=> (and (= (select2 Heap_ stack50000o_0 ownerRef_) stack50000o_0) (= (select2 Heap_ stack50000o_0 ownerFrame_) PeerGroupPlaceholder_)) (=> (= Heap_0_ (store2 Heap_ stack50000o_0 allocated_ Smt.true)) (and ?v_8 (=> ?v_8 (=> (= (IsHeap Heap_1_) Smt.true) (=> (and (or (= ?v_9 PeerGroupPlaceholder_) (not (subtypes (select2 Heap_1_ ?v_10 inv_) ?v_9)) (= (select2 Heap_1_ ?v_10 localinv_) (BaseClass_ ?v_9))) (= (select2 Heap_1_ stack50000o_0 inv_) Microsoft.Contracts.ObjectInvariantException) (= (select2 Heap_1_ stack50000o_0 localinv_) ?v_11)) (=> (and (= ?v_10 (select2 Heap_0_ stack50000o_0 ownerRef_)) (= ?v_9 (select2 Heap_0_ stack50000o_0 ownerFrame_))) (=> (= (select2 Heap_1_ stack50000o_0 sharingMode_) SharingMode_Unshared_) (=> (forall ((?o_ Int)) (let ((?v_30 (typeof_ ?o_))) (=> (and (not (= ?o_ nullObject)) (= (= (select2 Heap_0_ ?o_ allocated_) Smt.true) (not true)) (= (= (select2 Heap_1_ ?o_ allocated_) Smt.true) true)) (and (= (select2 Heap_1_ ?o_ inv_) ?v_30) (= (select2 Heap_1_ ?o_ localinv_) ?v_30))))) (=> (forall ((?o_ Int)) (! (let ((?v_31 (select2 Heap_0_ ?o_ FirstConsistentOwner_))) (=> (= (select2 Heap_0_ ?v_31 exposeVersion_) (select2 Heap_1_ ?v_31 exposeVersion_)) (= ?v_31 (select2 Heap_1_ ?o_ FirstConsistentOwner_)))) :pattern ((select2 Heap_1_ ?o_ FirstConsistentOwner_)) )) (=> (forall ((?o_ Int)) (=> (and (not (= ?o_ nullObject)) (= (= (select2 Heap_0_ ?o_ allocated_) Smt.true) true)) (and (= (select2 Heap_0_ ?o_ ownerRef_) (select2 Heap_1_ ?o_ ownerRef_)) (= (select2 Heap_0_ ?o_ ownerFrame_) (select2 Heap_1_ ?o_ ownerFrame_))))) (=> (forall ((?o_ Int) (?f_ Int)) (! (let ((?v_32 (select2 Heap_0_ ?o_ ownerFrame_)) (?v_33 (select2 Heap_0_ ?o_ ownerRef_))) (=> (and (not (= ?f_ inv_)) (not (= ?f_ localinv_)) (not (= ?f_ FirstConsistentOwner_)) (or (not (= (IsStaticField ?f_) Smt.true)) (not (= (IsDirectlyModifiableField ?f_) Smt.true))) (not (= ?o_ nullObject)) (= (= (select2 Heap_0_ ?o_ allocated_) Smt.true) true) (or (= ?v_32 PeerGroupPlaceholder_) (not (subtypes (select2 Heap_0_ ?v_33 inv_) ?v_32)) (= (select2 Heap_0_ ?v_33 localinv_) (BaseClass_ ?v_32))) (or (not (= ?o_ stack50000o_0)) (not (subtypes Microsoft.Contracts.ObjectInvariantException (DeclType ?f_)))) true) (= (select2 Heap_0_ ?o_ ?f_) (select2 Heap_1_ ?o_ ?f_)))) :pattern ((select2 Heap_1_ ?o_ ?f_)) )) (=> (forall ((?o_ Int)) (or (= ?o_ stack50000o_0) (and (= (select2 Heap_0_ ?o_ inv_) (select2 Heap_1_ ?o_ inv_)) (= (select2 Heap_0_ ?o_ localinv_) (select2 Heap_1_ ?o_ localinv_))) (= (= (select2 Heap_0_ ?o_ allocated_) Smt.true) (not true)))) (=> (and (forall ((?o_ Int)) (=> (= (= (select2 Heap_0_ ?o_ allocated_) Smt.true) true) (= (= (select2 Heap_1_ ?o_ allocated_) Smt.true) true))) (forall ((?ot_ Int)) (let ((?v_34 (select2 Heap_0_ ?ot_ ownerFrame_))) (=> (and (= (= (select2 Heap_0_ ?ot_ allocated_) Smt.true) true) (not (= ?v_34 PeerGroupPlaceholder_))) (and (= (select2 Heap_1_ ?ot_ ownerRef_) (select2 Heap_0_ ?ot_ ownerRef_)) (= (select2 Heap_1_ ?ot_ ownerFrame_) ?v_34))))) (= (= (select2 Heap_0_ BeingConstructed_ NonNullFieldsAreInitialized_) Smt.true) (= (select2 Heap_1_ BeingConstructed_ NonNullFieldsAreInitialized_) Smt.true))) (=> (forall ((?o_ Int)) (or (= ?o_ stack50000o_0) (= (select2 Heap_0_ ?o_ sharingMode_) (select2 Heap_1_ ?o_ sharingMode_)))) (and ?v_8 (=> ?v_8 (=> false (=> true ?v_12))))))))))))))))))))))) ?v_13) ?v_13))))) ?v_19) (=> (=> true (=> true (=> (not ?v_14) (=> true (=> (=> (=> true (=> true (=> true (=> (=> (=> true (=> (= stack0b_0 throwException_in) (=> (= local0_0 Smt.false) ?v_21))) ?v_16) ?v_16)))) ?v_17) ?v_17))))) ?v_18)) (and ?v_18 ?v_19))))) ?v_20) ?v_20))))) ?v_25) (=> (=> true (=> true (=> (<= stack0i_0 stack1i_0) (=> true (=> (=> (=> true (=> true (=> true (=> (=> (=> true (=> (= stack0b_0 stack0b) (=> (= local0_0 Smt.true) ?v_21))) ?v_22) ?v_22)))) ?v_23) ?v_23))))) ?v_24)) (and ?v_24 ?v_25))))))))))))))))) ?v_26) ?v_26)))) ?v_27) ?v_27))))))))))) ?v_28) ?v_28))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/ricart-agrawala6.smt2 b/test/regress/regress1/quantifiers/ricart-agrawala6.smt2 new file mode 100644 index 000000000..5f849de15 --- /dev/null +++ b/test/regress/regress1/quantifiers/ricart-agrawala6.smt2 @@ -0,0 +1,26 @@ +(set-logic AUFLIA) +(set-info :source | An Optimal Algorithm for Mutual Exclusion in Computer Networks. Glenn Ricart and Ashok K. Agrawala. Communications of the ACM Vol.: 24 Number: 1. This is a benchmark of the haRVey theorem prover. It was translated to SMT-LIB by Leonardo de Moura |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun p () Int) +(declare-fun q () Int) +(declare-fun r () Int) +(declare-fun s () Int) +(declare-fun s0 (Int) Bool) +(declare-fun s1 (Int) Bool) +(declare-fun s2 (Int) Bool) +(declare-fun s3 (Int) Bool) +(declare-fun s4 (Int) Bool) +(declare-fun s5 (Int) Bool) +(declare-fun s6 (Int) Bool) +(declare-fun rcs1 (Int) Bool) +(declare-fun rcs2 (Int) Bool) +(declare-fun x (Int Int) Bool) +(declare-fun ro (Int Int) Bool) +(declare-fun rd (Int Int) Bool) +(declare-fun sn (Int) Int) +(declare-fun time () Int) +(assert (not (=> (and (forall ((?p Int)) (forall ((?q Int)) (=> (or (s0 ?p) (s5 ?p)) (not (x ?p ?q))))) (forall ((?p Int)) (= (or (s0 ?p) (s6 ?p)) (not (rcs2 ?p)))) (forall ((?p Int)) (< (sn ?p) time)) (forall ((?p Int)) (forall ((?q Int)) (=> (not (= ?p ?q)) (not (= (sn ?p) (sn ?q)))))) (forall ((?p Int)) (forall ((?q Int)) (=> (and (not (= ?p ?q)) (or (and (s4 ?p) (x ?p ?q)) (s5 ?p)) (rcs2 ?q)) (< (sn ?p) (sn ?q))))) (forall ((?p Int)) (forall ((?q Int)) (=> (and (not (= ?p ?q)) (rd ?q ?p)) (ro ?p ?q)))) (forall ((?p Int)) (forall ((?q Int)) (let ((?v_0 (x ?p ?q))) (=> (not (= ?p ?q)) (= (not (or (and (s2 ?p) ?v_0) (and (s3 ?p) (not ?v_0)))) (=> (ro ?p ?q) (rd ?q ?p))))))) (forall ((?p Int)) (forall ((?q Int)) (let ((?v_1 (x ?q ?p))) (let ((?v_2 (or (and (s3 ?q) ?v_1) (and (s4 ?q) (not ?v_1))))) (=> (not (= ?p ?q)) (or (and (s6 ?p) (not (x ?p ?q)) ?v_2) (= (rd ?p ?q) (and ?v_2 (rcs2 ?p) (< (sn ?p) (sn ?q)))))))))) (forall ((?p Int)) (=> (s0 ?p) (not (or (s2 ?p) (s3 ?p) (s4 ?p) (s5 ?p) (s6 ?p))))) (forall ((?p Int)) (=> (s2 ?p) (not (or (s3 ?p) (s4 ?p) (s5 ?p) (s6 ?p))))) (forall ((?p Int)) (=> (s3 ?p) (not (or (s4 ?p) (s5 ?p) (s6 ?p))))) (forall ((?p Int)) (=> (s4 ?p) (not (or (s5 ?p) (s6 ?p))))) (forall ((?p Int)) (=> (s5 ?p) (not (s6 ?p)))) (forall ((?r Int)) (let ((?v_3 (not (= ?r p)))) (=> (s0 ?r) (not (or (s2 ?r) (and ?v_3 (=> ?v_3 (s3 ?r))) (=> ?v_3 (s4 ?r)) (s5 ?r) (s6 ?r)))))) (forall ((?r Int)) (let ((?v_4 (not (= ?r p)))) (=> (s2 ?r) (not (or (and ?v_4 (=> ?v_4 (s3 ?r))) (=> ?v_4 (s4 ?r)) (s5 ?r) (s6 ?r)))))) (forall ((?r Int)) (let ((?v_5 (not (= ?r p)))) (=> (and ?v_5 (=> ?v_5 (s3 ?r))) (not (or (=> ?v_5 (s4 ?r)) (s5 ?r) (s6 ?r)))))) (forall ((?r Int)) (=> (=> (not (= ?r p)) (s4 ?r)) (not (or (s5 ?r) (s6 ?r))))) (forall ((?r Int)) (=> (s5 ?r) (not (s6 ?r)))) (s3 p) (forall ((?q Int)) (=> (not (= ?q p)) (x p ?q)))) (and (forall ((?s Int)) (forall ((?r Int)) (let ((?v_6 (not (= ?s p)))) (=> (or (s0 ?s) (s5 ?s)) (not (and ?v_6 (=> ?v_6 (x ?s ?r)))))))) (forall ((?s Int)) (= (or (s0 ?s) (s6 ?s)) (not (rcs2 ?s)))) (forall ((?s Int)) (< (sn ?s) time)) (forall ((?s Int)) (forall ((?r Int)) (=> (not (= ?s ?r)) (not (= (sn ?s) (sn ?r)))))) (forall ((?s Int)) (forall ((?r Int)) (let ((?v_7 (not (= ?s p)))) (=> (and (not (= ?s ?r)) (or (and (=> ?v_7 (s4 ?s)) ?v_7 (=> ?v_7 (x ?s ?r))) (s5 ?s)) (rcs2 ?r)) (< (sn ?s) (sn ?r)))))) (forall ((?s Int)) (forall ((?r Int)) (=> (and (not (= ?s ?r)) (rd ?r ?s)) (ro ?s ?r)))) (forall ((?s Int)) (forall ((?r Int)) (let ((?v_8 (not (= ?s p)))) (let ((?v_9 (=> ?v_8 (x ?s ?r)))) (=> (not (= ?s ?r)) (= (not (or (and (s2 ?s) ?v_8 ?v_9) (and ?v_8 (=> ?v_8 (s3 ?s)) (not (and ?v_8 ?v_9))))) (=> (ro ?s ?r) (rd ?r ?s)))))))) (forall ((?s Int)) (forall ((?r Int)) (let ((?v_10 (not (= ?s p))) (?v_11 (not (= ?r p)))) (let ((?v_12 (=> ?v_11 (x ?r ?s)))) (let ((?v_13 (or (and ?v_11 (=> ?v_11 (s3 ?r)) ?v_11 ?v_12) (and (=> ?v_11 (s4 ?r)) (not (and ?v_11 ?v_12)))))) (=> (not (= ?s ?r)) (or (and (s6 ?s) (not (and ?v_10 (=> ?v_10 (x ?s ?r)))) ?v_13) (= (rd ?s ?r) (and ?v_13 (rcs2 ?s) (< (sn ?s) (sn ?r))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/set3.smt2 b/test/regress/regress1/quantifiers/set3.smt2 new file mode 100644 index 000000000..d3e51d996 --- /dev/null +++ b/test/regress/regress1/quantifiers/set3.smt2 @@ -0,0 +1,29 @@ +(set-logic AUFLIA) +(set-info :source | Assertion verification of simple set manipulation programs. |) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-sort Set 0) +(declare-fun member (Int Set) Bool) +(declare-fun insert (Set Int) Set) +(declare-fun delete (Set Int) Set) +(declare-fun sup (Set) Int) +(assert (forall ((?x Int) (?s Set)) (member ?x (insert ?s ?x)))) +(assert (forall ((?x Int) (?y Int) (?s Set)) (=> (not (= ?x ?y)) (= (member ?x (insert ?s ?y)) (member ?x ?s))))) +(assert (forall ((?x Int) (?s Set)) (=> (not (member ?x ?s)) (= (delete ?s ?x) ?s)))) +(assert (forall ((?x Int) (?s Set)) (= (delete (insert ?s ?x) ?x) (delete ?s ?x)))) +(assert (forall ((?x Int) (?y Int) (?s Set)) (=> (not (= ?x ?y)) (= (delete (insert ?s ?y) ?x) (insert (delete ?s ?x) ?y))))) +(assert (forall ((?s Set)) (member (sup ?s) ?s))) +(assert (forall ((?s Set) (?x Int)) (=> (member ?x ?s) (<= ?x (sup ?s))))) +(assert (forall ((?s Set) (?x Int)) (=> (< (sup ?s) ?x) (= (sup (insert ?s ?x)) ?x)))) +(declare-fun arr () (Array Int Int)) +(declare-fun s0 () Set) +(assert (forall ((?i Int)) (=> (> ?i 0) (< (select arr ?i) (sup s0))))) +(declare-fun i1 () Int) +(declare-fun s1 () Set) +(declare-fun g (Int) Int) +(assert (forall ((?i Int)) (> (g ?i) 0))) +(assert (= s1 (insert s0 (select arr (g i1))))) +(assert (not (= (sup s1) (sup s0)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/set8.smt2 b/test/regress/regress1/quantifiers/set8.smt2 new file mode 100644 index 000000000..684d94b7a --- /dev/null +++ b/test/regress/regress1/quantifiers/set8.smt2 @@ -0,0 +1,26 @@ +(set-logic AUFLIA) +(set-info :source | Set theory. |) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-sort Set 0) +(declare-sort Elem 0) +(declare-fun member (Elem Set) Bool) +(declare-fun subset (Set Set) Bool) +(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (=> (and (member ?x ?s1) (subset ?s1 ?s2)) (member ?x ?s2)))) +(assert (forall ((?s1 Set) (?s2 Set)) (=> (not (subset ?s1 ?s2)) (exists ((?x Elem)) (and (member ?x ?s1) (not (member ?x ?s2))))))) +(assert (forall ((?s1 Set) (?s2 Set)) (=> (forall ((?x Elem)) (=> (member ?x ?s1) (member ?x ?s2))) (subset ?s1 ?s2)))) +(declare-fun seteq (Set Set) Bool) +(assert (forall ((?s1 Set) (?s2 Set)) (= (seteq ?s1 ?s2) (= ?s1 ?s2)))) +(assert (forall ((?s1 Set) (?s2 Set)) (= (seteq ?s1 ?s2) (and (subset ?s1 ?s2) (subset ?s2 ?s1))))) +(declare-fun union (Set Set) Set) +(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (member ?x (union ?s1 ?s2)) (or (member ?x ?s1) (member ?x ?s2))))) +(declare-fun intersection (Set Set) Set) +(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (member ?x (intersection ?s1 ?s2)) (and (member ?x ?s1) (member ?x ?s2))))) +(declare-fun difference (Set Set) Set) +(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (member ?x (difference ?s1 ?s2)) (and (member ?x ?s1) (not (member ?x ?s2)))))) +(declare-fun a () Set) +(declare-fun b () Set) +(assert (not (seteq (intersection a b) (intersection b a)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/small-pipeline-fixpoint-3.smt2 b/test/regress/regress1/quantifiers/small-pipeline-fixpoint-3.smt2 new file mode 100644 index 000000000..378912490 --- /dev/null +++ b/test/regress/regress1/quantifiers/small-pipeline-fixpoint-3.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --cbqi-bv --no-check-models +; EXPECT: unsat +(set-logic BV) +(set-info :status unsat) +(assert (forall ((Verilog__main.dataOut_64_0 (_ BitVec 32))) (forall ((Verilog__main.stageOne_64_0 (_ BitVec 32))) (forall ((Verilog__main.stageTwo_64_0 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageOne_64_0 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageTwo_64_0 (_ BitVec 32))) (forall ((Verilog__main.dataOut_64_1 (_ BitVec 32))) (forall ((Verilog__main.reset_64_0 Bool)) (forall ((Verilog__main.stageOne_64_1 (_ BitVec 32))) (forall ((Verilog__main.dataIn_64_0 (_ BitVec 32))) (forall ((Verilog__main.c1_64_0 (_ BitVec 32))) (forall ((Verilog__main.stageTwo_64_1 (_ BitVec 32))) (forall ((Verilog__main.c2_64_0 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageOne_64_1 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageTwo_64_1 (_ BitVec 32))) (forall ((Verilog__main.dataOut_64_2 (_ BitVec 32))) (forall ((Verilog__main.reset_64_1 Bool)) (forall ((Verilog__main.stageOne_64_2 (_ BitVec 32))) (forall ((Verilog__main.dataIn_64_1 (_ BitVec 32))) (forall ((Verilog__main.c1_64_1 (_ BitVec 32))) (forall ((Verilog__main.stageTwo_64_2 (_ BitVec 32))) (forall ((Verilog__main.c2_64_1 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageOne_64_2 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageTwo_64_2 (_ BitVec 32))) (forall ((Verilog__main.dataOut_64_3 (_ BitVec 32))) (forall ((Verilog__main.reset_64_2 Bool)) (forall ((Verilog__main.stageOne_64_3 (_ BitVec 32))) (forall ((Verilog__main.dataIn_64_2 (_ BitVec 32))) (forall ((Verilog__main.c1_64_2 (_ BitVec 32))) (forall ((Verilog__main.stageTwo_64_3 (_ BitVec 32))) (forall ((Verilog__main.c2_64_2 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageOne_64_3 (_ BitVec 32))) (forall ((Verilog__main.tmp_stageTwo_64_3 (_ BitVec 32))) (exists ((Verilog__main.dataOut_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.stageOne_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.stageTwo_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.tmp_stageOne_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.tmp_stageTwo_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.dataOut_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.reset_64_0_39_ Bool)) (exists ((Verilog__main.stageOne_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.dataIn_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.c1_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.stageTwo_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.c2_64_0_39_ (_ BitVec 32))) (exists ((Verilog__main.tmp_stageOne_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.tmp_stageTwo_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.dataOut_64_2_39_ (_ BitVec 32))) (exists ((Verilog__main.reset_64_1_39_ Bool)) (exists ((Verilog__main.stageOne_64_2_39_ (_ BitVec 32))) (exists ((Verilog__main.dataIn_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.c1_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.stageTwo_64_2_39_ (_ BitVec 32))) (exists ((Verilog__main.c2_64_1_39_ (_ BitVec 32))) (exists ((Verilog__main.tmp_stageOne_64_2_39_ (_ BitVec 32))) (exists ((Verilog__main.tmp_stageTwo_64_2_39_ (_ BitVec 32))) (=> (and (and (= Verilog__main.dataOut_64_0 (_ bv0 32)) (= Verilog__main.stageOne_64_0 (_ bv0 32)) (= Verilog__main.stageTwo_64_0 (_ bv0 32)) (= Verilog__main.tmp_stageOne_64_0 (_ bv0 32)) (= Verilog__main.tmp_stageTwo_64_0 (_ bv0 32))) (and (= Verilog__main.dataOut_64_1 (ite (not Verilog__main.reset_64_0) (bvadd Verilog__main.stageTwo_64_0 Verilog__main.stageOne_64_0) (_ bv0 32))) (= Verilog__main.stageOne_64_1 (bvadd Verilog__main.dataIn_64_0 Verilog__main.c1_64_0)) (= Verilog__main.stageTwo_64_1 (bvand Verilog__main.stageOne_64_0 Verilog__main.c2_64_0)) (= Verilog__main.tmp_stageOne_64_1 Verilog__main.stageOne_64_0) (= Verilog__main.tmp_stageTwo_64_1 Verilog__main.stageTwo_64_0)) (and (= Verilog__main.dataOut_64_2 (ite (not Verilog__main.reset_64_1) (bvadd Verilog__main.stageTwo_64_1 Verilog__main.stageOne_64_1) (_ bv0 32))) (= Verilog__main.stageOne_64_2 (bvadd Verilog__main.dataIn_64_1 Verilog__main.c1_64_1)) (= Verilog__main.stageTwo_64_2 (bvand Verilog__main.stageOne_64_1 Verilog__main.c2_64_1)) (= Verilog__main.tmp_stageOne_64_2 Verilog__main.stageOne_64_1) (= Verilog__main.tmp_stageTwo_64_2 Verilog__main.stageTwo_64_1)) (and (= Verilog__main.dataOut_64_3 (ite (not Verilog__main.reset_64_2) (bvadd Verilog__main.stageTwo_64_2 Verilog__main.stageOne_64_2) (_ bv0 32))) (= Verilog__main.stageOne_64_3 (bvadd Verilog__main.dataIn_64_2 Verilog__main.c1_64_2)) (= Verilog__main.stageTwo_64_3 (bvand Verilog__main.stageOne_64_2 Verilog__main.c2_64_2)) (= Verilog__main.tmp_stageOne_64_3 Verilog__main.stageOne_64_2) (= Verilog__main.tmp_stageTwo_64_3 Verilog__main.stageTwo_64_2))) (and (and (and (= Verilog__main.dataOut_64_0_39_ (_ bv0 32)) (= Verilog__main.stageOne_64_0_39_ (_ bv0 32)) (= Verilog__main.stageTwo_64_0_39_ (_ bv0 32)) (= Verilog__main.tmp_stageOne_64_0_39_ (_ bv0 32)) (= Verilog__main.tmp_stageTwo_64_0_39_ (_ bv0 32))) (and (= Verilog__main.dataOut_64_1_39_ (ite (not Verilog__main.reset_64_0_39_) (bvadd Verilog__main.stageTwo_64_0_39_ Verilog__main.stageOne_64_0_39_) (_ bv0 32))) (= Verilog__main.stageOne_64_1_39_ (bvadd Verilog__main.dataIn_64_0_39_ Verilog__main.c1_64_0_39_)) (= Verilog__main.stageTwo_64_1_39_ (bvand Verilog__main.stageOne_64_0_39_ Verilog__main.c2_64_0_39_)) (= Verilog__main.tmp_stageOne_64_1_39_ Verilog__main.stageOne_64_0_39_) (= Verilog__main.tmp_stageTwo_64_1_39_ Verilog__main.stageTwo_64_0_39_)) (and (= Verilog__main.dataOut_64_2_39_ (ite (not Verilog__main.reset_64_1_39_) (bvadd Verilog__main.stageTwo_64_1_39_ Verilog__main.stageOne_64_1_39_) (_ bv0 32))) (= Verilog__main.stageOne_64_2_39_ (bvadd Verilog__main.dataIn_64_1_39_ Verilog__main.c1_64_1_39_)) (= Verilog__main.stageTwo_64_2_39_ (bvand Verilog__main.stageOne_64_1_39_ Verilog__main.c2_64_1_39_)) (= Verilog__main.tmp_stageOne_64_2_39_ Verilog__main.stageOne_64_1_39_) (= Verilog__main.tmp_stageTwo_64_2_39_ Verilog__main.stageTwo_64_1_39_))) (or (and (= Verilog__main.dataOut_64_3 Verilog__main.dataOut_64_0_39_) (= Verilog__main.stageOne_64_3 Verilog__main.stageOne_64_0_39_) (= Verilog__main.stageTwo_64_3 Verilog__main.stageTwo_64_0_39_) (= Verilog__main.tmp_stageOne_64_3 Verilog__main.tmp_stageOne_64_0_39_) (= Verilog__main.tmp_stageTwo_64_3 Verilog__main.tmp_stageTwo_64_0_39_)) (and (= Verilog__main.dataOut_64_3 Verilog__main.dataOut_64_1_39_) (= Verilog__main.stageOne_64_3 Verilog__main.stageOne_64_1_39_) (= Verilog__main.stageTwo_64_3 Verilog__main.stageTwo_64_1_39_) (= Verilog__main.tmp_stageOne_64_3 Verilog__main.tmp_stageOne_64_1_39_) (= Verilog__main.tmp_stageTwo_64_3 Verilog__main.tmp_stageTwo_64_1_39_)) (and (= Verilog__main.dataOut_64_3 Verilog__main.dataOut_64_2_39_) (= Verilog__main.stageOne_64_3 Verilog__main.stageOne_64_2_39_) (= Verilog__main.stageTwo_64_3 Verilog__main.stageTwo_64_2_39_) (= Verilog__main.tmp_stageOne_64_3 Verilog__main.tmp_stageOne_64_2_39_) (= Verilog__main.tmp_stageTwo_64_3 Verilog__main.tmp_stageTwo_64_2_39_))))) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/smtlib384a03.smt2 b/test/regress/regress1/quantifiers/smtlib384a03.smt2 new file mode 100644 index 000000000..9e2273cff --- /dev/null +++ b/test/regress/regress1/quantifiers/smtlib384a03.smt2 @@ -0,0 +1,205 @@ +(set-logic AUFLIRA) +(set-info :source |http://proval.lri.fr/why-benchmarks |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-sort Unit 0) +(declare-sort c_unique 0) +(declare-sort c_ssorted 0) +(declare-sort c_type 0) +(declare-sort c_Boolean 0) +(declare-fun c_sort (c_type c_unique) c_ssorted) +(declare-fun c_Boolean_true () c_Boolean) +(declare-fun c_Boolean_false () c_Boolean) +(assert (forall ((?b_22_1 c_Boolean)) (or (= c_Boolean_true ?b_22_1) (= c_Boolean_false ?b_22_1)))) +(assert (not (= c_Boolean_true c_Boolean_false))) +(declare-fun int2U (Int) c_unique) +(declare-fun ss2Int (c_ssorted) Int) +(declare-fun real2U (Real) c_unique) +(declare-fun ss2Real (c_ssorted) Real) +(declare-fun bool2U (c_Boolean) c_unique) +(declare-fun ss2Bool (c_ssorted) c_Boolean) +(declare-fun c_int () c_type) +(declare-fun c_bool () c_type) +(declare-fun c_real () c_type) +(declare-fun c_unit () c_type) +(declare-fun c_ref (c_unique) c_unique) +(assert (forall ((?t_21_2 c_type)) (forall ((?x_20_3 c_unique)) (forall ((?y_19_4 c_unique)) (=> (= (c_sort ?t_21_2 ?x_20_3) (c_sort ?t_21_2 ?y_19_4)) (= ?x_20_3 ?y_19_4)))))) +(assert (forall ((?x_18_5 Int)) (= (ss2Int (c_sort c_int (int2U ?x_18_5))) ?x_18_5))) +(assert (forall ((?x_17_6 Int)) (forall ((?y_16_7 Int)) (=> (= (int2U ?x_17_6) (int2U ?y_16_7)) (= ?x_17_6 ?y_16_7))))) +(assert (forall ((?x_15_8 Real)) (forall ((?y_14_9 Real)) (=> (= (real2U ?x_15_8) (real2U ?y_14_9)) (= ?x_15_8 ?y_14_9))))) +(assert (forall ((?x_13_10 c_Boolean)) (forall ((?y_12_11 c_Boolean)) (=> (= (bool2U ?x_13_10) (bool2U ?y_12_11)) (= ?x_13_10 ?y_12_11))))) +(assert (forall ((?x_11_12 c_ssorted)) (forall ((?y_10_13 c_ssorted)) (=> (= (ss2Int ?x_11_12) (ss2Int ?y_10_13)) (= ?x_11_12 ?y_10_13))))) +(assert (forall ((?x_9_14 c_ssorted)) (forall ((?y_8_15 c_ssorted)) (=> (= (ss2Real ?x_9_14) (ss2Real ?y_8_15)) (= ?x_9_14 ?y_8_15))))) +(assert (forall ((?x_7_16 c_ssorted)) (forall ((?y_6_17 c_ssorted)) (=> (= (ss2Bool ?x_7_16) (ss2Bool ?y_6_17)) (= ?x_7_16 ?y_6_17))))) +(assert (forall ((?x_5_18 Real)) (= (ss2Real (c_sort c_real (real2U ?x_5_18))) ?x_5_18))) +(assert (forall ((?x_4_19 c_Boolean)) (= (ss2Bool (c_sort c_bool (bool2U ?x_4_19))) ?x_4_19))) +(assert (forall ((?x_3_20 c_unique)) (= (int2U (ss2Int (c_sort c_int ?x_3_20))) ?x_3_20))) +(assert (forall ((?x_2_21 c_unique)) (= (real2U (ss2Real (c_sort c_real ?x_2_21))) ?x_2_21))) +(assert (forall ((?x_1_22 c_unique)) (= (bool2U (ss2Bool (c_sort c_bool ?x_1_22))) ?x_1_22))) +(declare-fun eq_int (Int Int) Bool) +(declare-fun neq_int (Int Int) Bool) +(declare-fun lt_int_bool (Int Int) c_Boolean) +(declare-fun le_int_bool (Int Int) c_Boolean) +(declare-fun gt_int_bool (Int Int) c_Boolean) +(declare-fun ge_int_bool (Int Int) c_Boolean) +(declare-fun eq_int_bool (Int Int) c_Boolean) +(declare-fun neq_int_bool (Int Int) c_Boolean) +(assert (forall ((?x_40_23 Int)) (forall ((?y_39_24 Int)) (= (= (lt_int_bool ?x_40_23 ?y_39_24) c_Boolean_true) (< ?x_40_23 ?y_39_24))))) +(assert (forall ((?x_42_25 Int)) (forall ((?y_41_26 Int)) (= (= (le_int_bool ?x_42_25 ?y_41_26) c_Boolean_true) (<= ?x_42_25 ?y_41_26))))) +(assert (forall ((?x_44_27 Int)) (forall ((?y_43_28 Int)) (= (= (gt_int_bool ?x_44_27 ?y_43_28) c_Boolean_true) (> ?x_44_27 ?y_43_28))))) +(assert (forall ((?x_46_29 Int)) (forall ((?y_45_30 Int)) (= (= (ge_int_bool ?x_46_29 ?y_45_30) c_Boolean_true) (>= ?x_46_29 ?y_45_30))))) +(assert (forall ((?x_48_31 Int)) (forall ((?y_47_32 Int)) (= (= (eq_int_bool ?x_48_31 ?y_47_32) c_Boolean_true) (= ?x_48_31 ?y_47_32))))) +(assert (forall ((?x_50_33 Int)) (forall ((?y_49_34 Int)) (= (= (neq_int_bool ?x_50_33 ?y_49_34) c_Boolean_true) (not (= ?x_50_33 ?y_49_34)))))) +(declare-fun add_real (Real Real) Real) +(declare-fun sub_real (Real Real) Real) +(declare-fun mul_real (Real Real) Real) +(declare-fun div_real (Real Real) Real) +(declare-fun pow_real (Real Real) Real) +(declare-fun neg_real (Real) Real) +(declare-fun abs_real (Real) Real) +(declare-fun sqrt_real (Real) Real) +(declare-fun real_of_int (Int) Real) +(declare-fun int_of_real (Real) Int) +(declare-fun lt_real (Real Real) Bool) +(declare-fun le_real (Real Real) Bool) +(declare-fun gt_real (Real Real) Bool) +(declare-fun ge_real (Real Real) Bool) +(declare-fun eq_real (Real Real) Bool) +(declare-fun neq_real (Real Real) Bool) +(declare-fun eq_bool (c_Boolean c_Boolean) Bool) +(declare-fun neq_bool (c_Boolean c_Boolean) Bool) +(declare-fun eq_unit (c_ssorted c_ssorted) Bool) +(declare-fun neq_unit (c_ssorted c_ssorted) Bool) +(declare-fun smtlib__ite (c_Boolean c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_1_76_35 c_type)) (forall ((?x_75_36 c_unique)) (forall ((?y_74_37 c_unique)) (= (smtlib__ite c_Boolean_true (c_sort ?t_1_76_35 ?x_75_36) (c_sort ?t_1_76_35 ?y_74_37)) ?x_75_36))))) +(assert (forall ((?t_2_79_38 c_type)) (forall ((?x_78_39 c_unique)) (forall ((?y_77_40 c_unique)) (= (smtlib__ite c_Boolean_false (c_sort ?t_2_79_38 ?x_78_39) (c_sort ?t_2_79_38 ?y_77_40)) ?y_77_40))))) +(declare-fun bw_compl (Int) Int) +(declare-fun bw_and (Int Int) Int) +(declare-fun bw_xor (Int Int) Int) +(declare-fun bw_or (Int Int) Int) +(declare-fun lsl (Int Int) Int) +(declare-fun lsr (Int Int) Int) +(declare-fun non_int (Int) Int) +(declare-fun type_pointer (c_type) c_type) +(declare-fun type_addr (c_type) c_type) +(declare-fun type_alloc_table () c_type) +(declare-fun block_length (c_ssorted c_ssorted) Int) +(declare-fun base_addr (c_ssorted) c_unique) +(declare-fun offset (c_ssorted) Int) +(declare-fun shift (c_ssorted Int) c_unique) +(declare-fun sub_pointer (c_ssorted c_ssorted) Int) +(declare-fun lt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_3_88_41 c_type)) (forall ((?p1_87_42 c_unique)) (forall ((?p2_86_43 c_unique)) (let ((?v_0 (type_pointer ?t_3_88_41))) (let ((?v_1 (c_sort ?v_0 ?p1_87_42)) (?v_2 (c_sort ?v_0 ?p2_86_43))) (= (lt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (< (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun le_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_4_91_44 c_type)) (forall ((?p1_90_45 c_unique)) (forall ((?p2_89_46 c_unique)) (let ((?v_0 (type_pointer ?t_4_91_44))) (let ((?v_1 (c_sort ?v_0 ?p1_90_45)) (?v_2 (c_sort ?v_0 ?p2_89_46))) (= (le_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (<= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun gt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_5_94_47 c_type)) (forall ((?p1_93_48 c_unique)) (forall ((?p2_92_49 c_unique)) (let ((?v_0 (type_pointer ?t_5_94_47))) (let ((?v_1 (c_sort ?v_0 ?p1_93_48)) (?v_2 (c_sort ?v_0 ?p2_92_49))) (= (gt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (> (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun ge_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_6_97_50 c_type)) (forall ((?p1_96_51 c_unique)) (forall ((?p2_95_52 c_unique)) (let ((?v_0 (type_pointer ?t_6_97_50))) (let ((?v_1 (c_sort ?v_0 ?p1_96_51)) (?v_2 (c_sort ?v_0 ?p2_95_52))) (= (ge_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (>= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun valid (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_7_104_53 c_type)) (forall ((?a_103_54 c_unique)) (forall ((?p_102_55 c_unique)) (let ((?v_2 (c_sort type_alloc_table ?a_103_54)) (?v_0 (c_sort (type_pointer ?t_7_104_53) ?p_102_55))) (let ((?v_1 (offset ?v_0))) (= (valid ?v_2 ?v_0) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0)))))))))) +(declare-fun valid_index (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_8_108_56 c_type)) (forall ((?a_107_57 c_unique)) (forall ((?p_106_58 c_unique)) (forall ((?i_105_59 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_107_57)) (?v_0 (c_sort (type_pointer ?t_8_108_56) ?p_106_58))) (let ((?v_1 (+ (offset ?v_0) ?i_105_59))) (= (valid_index ?v_2 ?v_0 ?i_105_59) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0))))))))))) +(declare-fun valid_range (c_ssorted c_ssorted Int Int) Bool) +(assert (forall ((?t_9_113_60 c_type)) (forall ((?a_112_61 c_unique)) (forall ((?p_111_62 c_unique)) (forall ((?i_110_63 Int)) (forall ((?j_109_64 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_112_61)) (?v_0 (c_sort (type_pointer ?t_9_113_60) ?p_111_62))) (let ((?v_1 (offset ?v_0))) (= (valid_range ?v_2 ?v_0 ?i_110_63 ?j_109_64) (and (<= 0 (+ ?v_1 ?i_110_63)) (< (+ ?v_1 ?j_109_64) (block_length ?v_2 ?v_0)))))))))))) +(assert (forall ((?t_10_116_65 c_type)) (forall ((?p_115_66 c_unique)) (forall ((?i_114_67 Int)) (let ((?v_0 (type_pointer ?t_10_116_65))) (let ((?v_1 (c_sort ?v_0 ?p_115_66))) (= (offset (c_sort ?v_0 (shift ?v_1 ?i_114_67))) (+ (offset ?v_1) ?i_114_67)))))))) +(assert (forall ((?t_11_118_68 c_type)) (forall ((?p_117_69 c_unique)) (= (shift (c_sort (type_pointer ?t_11_118_68) ?p_117_69) 0) ?p_117_69)))) +(assert (forall ((?t_12_122_70 c_type)) (forall ((?p_121_71 c_unique)) (forall ((?i_120_72 Int)) (forall ((?j_119_73 Int)) (let ((?v_0 (type_pointer ?t_12_122_70))) (let ((?v_1 (c_sort ?v_0 ?p_121_71))) (= (shift (c_sort ?v_0 (shift ?v_1 ?i_120_72)) ?j_119_73) (shift ?v_1 (+ ?i_120_72 ?j_119_73)))))))))) +(assert (forall ((?t_13_125_74 c_type)) (forall ((?p_124_75 c_unique)) (forall ((?i_123_76 Int)) (let ((?v_0 (type_pointer ?t_13_125_74))) (let ((?v_1 (c_sort ?v_0 ?p_124_75))) (= (base_addr (c_sort ?v_0 (shift ?v_1 ?i_123_76))) (base_addr ?v_1)))))))) +(assert (forall ((?t_14_129_77 c_type)) (forall ((?a_128_78 c_unique)) (forall ((?p_127_79 c_unique)) (forall ((?i_126_80 Int)) (let ((?v_1 (c_sort type_alloc_table ?a_128_78)) (?v_0 (type_pointer ?t_14_129_77))) (let ((?v_2 (c_sort ?v_0 ?p_127_79))) (= (block_length ?v_1 (c_sort ?v_0 (shift ?v_2 ?i_126_80))) (block_length ?v_1 ?v_2))))))))) +(assert (forall ((?t_15_133_81 c_type)) (forall ((?a_132_82 c_unique)) (forall ((?p1_131_83 c_unique)) (forall ((?p2_130_84 c_unique)) (let ((?v_0 (type_pointer ?t_15_133_81))) (let ((?v_1 (c_sort ?v_0 ?p1_131_83)) (?v_3 (c_sort ?v_0 ?p2_130_84)) (?v_2 (c_sort type_alloc_table ?a_132_82))) (=> (= (base_addr ?v_1) (base_addr ?v_3)) (= (block_length ?v_2 ?v_1) (block_length ?v_2 ?v_3)))))))))) +(assert (forall ((?t_16_136_85 c_type)) (forall ((?p1_135_86 c_unique)) (forall ((?p2_134_87 c_unique)) (let ((?v_0 (type_pointer ?t_16_136_85))) (let ((?v_1 (c_sort ?v_0 ?p1_135_86)) (?v_2 (c_sort ?v_0 ?p2_134_87))) (=> (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2))) (= ?p1_135_86 ?p2_134_87)))))))) +(assert (forall ((?t_17_139_88 c_type)) (forall ((?p1_138_89 c_unique)) (forall ((?p2_137_90 c_unique)) (let ((?v_0 (type_pointer ?t_17_139_88))) (let ((?v_1 (c_sort ?v_0 ?p1_138_89)) (?v_2 (c_sort ?v_0 ?p2_137_90))) (=> (= ?p1_138_89 ?p2_137_90) (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2)))))))))) +(assert (forall ((?t_18_144_91 c_type)) (forall ((?p1_143_92 c_unique)) (forall ((?p2_142_93 c_unique)) (forall ((?i_141_94 Int)) (forall ((?j_140_95 Int)) (let ((?v_0 (type_pointer ?t_18_144_91))) (let ((?v_1 (c_sort ?v_0 ?p1_143_92)) (?v_2 (c_sort ?v_0 ?p2_142_93))) (=> (not (= (base_addr ?v_1) (base_addr ?v_2))) (not (= (shift ?v_1 ?i_141_94) (shift ?v_2 ?j_140_95)))))))))))) +(assert (forall ((?t_19_149_96 c_type)) (forall ((?p1_148_97 c_unique)) (forall ((?p2_147_98 c_unique)) (forall ((?i_146_99 Int)) (forall ((?j_145_100 Int)) (let ((?v_0 (type_pointer ?t_19_149_96))) (let ((?v_1 (c_sort ?v_0 ?p1_148_97)) (?v_2 (c_sort ?v_0 ?p2_147_98))) (=> (not (= (+ (offset ?v_1) ?i_146_99) (+ (offset ?v_2) ?j_145_100))) (not (= (shift ?v_1 ?i_146_99) (shift ?v_2 ?j_145_100)))))))))))) +(assert (forall ((?t_20_154_101 c_type)) (forall ((?p1_153_102 c_unique)) (forall ((?p2_152_103 c_unique)) (forall ((?i_151_104 Int)) (forall ((?j_150_105 Int)) (let ((?v_0 (type_pointer ?t_20_154_101))) (let ((?v_1 (c_sort ?v_0 ?p1_153_102)) (?v_2 (c_sort ?v_0 ?p2_152_103))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (=> (= (+ (offset ?v_1) ?i_151_104) (+ (offset ?v_2) ?j_150_105)) (= (shift ?v_1 ?i_151_104) (shift ?v_2 ?j_150_105)))))))))))) +(assert (forall ((?t_21_158_106 c_type)) (forall ((?a_157_107 c_unique)) (forall ((?p_156_108 c_unique)) (forall ((?i_155_109 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_157_107)) (?v_1 (type_pointer ?t_21_158_106))) (let ((?v_2 (c_sort ?v_1 ?p_156_108))) (=> (valid_index ?v_0 ?v_2 ?i_155_109) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?i_155_109))))))))))) +(assert (forall ((?t_22_164_110 c_type)) (forall ((?a_163_111 c_unique)) (forall ((?p_162_112 c_unique)) (forall ((?i_161_113 Int)) (forall ((?j_160_114 Int)) (forall ((?k_159_115 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_163_111)) (?v_1 (type_pointer ?t_22_164_110))) (let ((?v_2 (c_sort ?v_1 ?p_162_112))) (=> (valid_range ?v_0 ?v_2 ?i_161_113 ?j_160_114) (=> (and (<= ?i_161_113 ?k_159_115) (<= ?k_159_115 ?j_160_114)) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?k_159_115)))))))))))))) +(assert (forall ((?t_23_169_116 c_type)) (forall ((?a_168_117 c_unique)) (forall ((?p_167_118 c_unique)) (forall ((?i_166_119 Int)) (forall ((?j_165_120 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_168_117)) (?v_1 (c_sort (type_pointer ?t_23_169_116) ?p_167_118))) (=> (valid_range ?v_0 ?v_1 ?i_166_119 ?j_165_120) (=> (and (<= ?i_166_119 0) (<= 0 ?j_165_120)) (valid ?v_0 ?v_1)))))))))) +(assert (forall ((?t_24_175_121 c_type)) (forall ((?a_174_122 c_unique)) (forall ((?p_173_123 c_unique)) (forall ((?i_172_124 Int)) (forall ((?j_171_125 Int)) (forall ((?k_170_126 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_174_122)) (?v_1 (c_sort (type_pointer ?t_24_175_121) ?p_173_123))) (=> (valid_range ?v_0 ?v_1 ?i_172_124 ?j_171_125) (=> (and (<= ?i_172_124 ?k_170_126) (<= ?k_170_126 ?j_171_125)) (valid_index ?v_0 ?v_1 ?k_170_126))))))))))) +(assert (forall ((?t_25_178_127 c_type)) (forall ((?p1_177_128 c_unique)) (forall ((?p2_176_129 c_unique)) (let ((?v_0 (type_pointer ?t_25_178_127))) (let ((?v_1 (c_sort ?v_0 ?p1_177_128)) (?v_2 (c_sort ?v_0 ?p2_176_129))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (= (sub_pointer ?v_1 ?v_2) (- (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun type_memory (c_type c_type) c_type) +(declare-fun acc (c_ssorted c_ssorted) c_unique) +(declare-fun upd (c_ssorted c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_27_212_130 c_type)) (forall ((?t_26_211_131 c_type)) (forall ((?m_210_132 c_unique)) (forall ((?p_209_133 c_unique)) (forall ((?a_208_134 c_unique)) (let ((?v_0 (type_memory ?t_26_211_131 ?t_27_212_130)) (?v_1 (c_sort (type_pointer ?t_27_212_130) ?p_209_133))) (= (acc (c_sort ?v_0 (upd (c_sort ?v_0 ?m_210_132) ?v_1 (c_sort ?t_26_211_131 ?a_208_134))) ?v_1) ?a_208_134)))))))) +(assert (forall ((?t_29_218_135 c_type)) (forall ((?t_28_217_136 c_type)) (forall ((?m_216_137 c_unique)) (forall ((?p1_215_138 c_unique)) (forall ((?p2_214_139 c_unique)) (forall ((?a_213_140 c_unique)) (let ((?v_0 (type_memory ?t_28_217_136 ?t_29_218_135))) (let ((?v_2 (c_sort ?v_0 ?m_216_137)) (?v_1 (type_pointer ?t_29_218_135))) (let ((?v_3 (c_sort ?v_1 ?p2_214_139))) (=> (not (= ?p1_215_138 ?p2_214_139)) (= (acc (c_sort ?v_0 (upd ?v_2 (c_sort ?v_1 ?p1_215_138) (c_sort ?t_28_217_136 ?a_213_140))) ?v_3) (acc ?v_2 ?v_3))))))))))))) +(assert (not (= c_Boolean_false c_Boolean_true))) +(declare-fun type_pset (c_type) c_type) +(declare-fun pset_empty () c_unique) +(declare-fun pset_singleton (c_ssorted) c_unique) +(declare-fun pset_star (c_ssorted c_ssorted) c_unique) +(declare-fun pset_all (c_ssorted) c_unique) +(declare-fun pset_range (c_ssorted Int Int) c_unique) +(declare-fun pset_range_left (c_ssorted Int) c_unique) +(declare-fun pset_range_right (c_ssorted Int) c_unique) +(declare-fun pset_acc_all (c_ssorted c_ssorted) c_unique) +(declare-fun pset_acc_range (c_ssorted c_ssorted Int Int) c_unique) +(declare-fun pset_acc_range_left (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_acc_range_right (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_union (c_ssorted c_ssorted) c_unique) +(declare-fun not_in_pset (c_ssorted c_ssorted) Bool) +(declare-fun not_assigns (c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_31_225_141 c_type)) (forall ((?t_30_224_142 c_type)) (forall ((?a_223_143 c_unique)) (forall ((?m1_222_144 c_unique)) (forall ((?m2_221_145 c_unique)) (forall ((?l_220_146 c_unique)) (let ((?v_0 (type_memory ?t_30_224_142 ?t_31_225_141))) (= (not_assigns (c_sort type_alloc_table ?a_223_143) (c_sort ?v_0 ?m1_222_144) (c_sort ?v_0 ?m2_221_145) (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (forall ((?p_219_147 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_31_225_141) ?p_219_147))) (=> (valid (c_sort type_alloc_table ?a_223_143) ?v_1) (=> (not_in_pset ?v_1 (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (= (acc (c_sort ?v_0 ?m2_221_145) ?v_1) (acc (c_sort ?v_0 ?m1_222_144) ?v_1))))))))))))))) +(assert (forall ((?t_32_227_148 c_type)) (forall ((?p_226_149 c_unique)) (not_in_pset (c_sort (type_pointer ?t_32_227_148) ?p_226_149) (c_sort (type_pset ?t_32_227_148) pset_empty))))) +(assert (forall ((?t_33_230_150 c_type)) (forall ((?p1_229_151 c_unique)) (forall ((?p2_228_152 c_unique)) (let ((?v_0 (type_pointer ?t_33_230_150))) (=> (not (= ?p1_229_151 ?p2_228_152)) (not_in_pset (c_sort ?v_0 ?p1_229_151) (c_sort (type_pset ?t_33_230_150) (pset_singleton (c_sort ?v_0 ?p2_228_152)))))))))) +(assert (forall ((?t_34_233_153 c_type)) (forall ((?p1_232_154 c_unique)) (forall ((?p2_231_155 c_unique)) (let ((?v_0 (type_pointer ?t_34_233_153))) (=> (not_in_pset (c_sort ?v_0 ?p1_232_154) (c_sort (type_pset ?t_34_233_153) (pset_singleton (c_sort ?v_0 ?p2_231_155)))) (not (= ?p1_232_154 ?p2_231_155)))))))) +(assert (forall ((?t_35_235_156 c_type)) (forall ((?p_234_157 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_35_235_156) ?p_234_157))) (not (not_in_pset ?v_0 (c_sort (type_pset ?t_35_235_156) (pset_singleton ?v_0)))))))) +(assert (forall ((?t_36_239_158 c_type)) (forall ((?l1_238_159 c_unique)) (forall ((?l2_237_160 c_unique)) (forall ((?p_236_161 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_36_239_158) ?p_236_161)) (?v_1 (type_pset ?t_36_239_158))) (let ((?v_2 (c_sort ?v_1 ?l1_238_159)) (?v_3 (c_sort ?v_1 ?l2_237_160))) (=> (and (not_in_pset ?v_0 ?v_2) (not_in_pset ?v_0 ?v_3)) (not_in_pset ?v_0 (c_sort ?v_1 (pset_union ?v_2 ?v_3))))))))))) +(assert (forall ((?t_37_243_162 c_type)) (forall ((?l1_242_163 c_unique)) (forall ((?l2_241_164 c_unique)) (forall ((?p_240_165 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_37_243_162) ?p_240_165)) (?v_0 (type_pset ?t_37_243_162))) (let ((?v_2 (c_sort ?v_0 ?l1_242_163))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union ?v_2 (c_sort ?v_0 ?l2_241_164)))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_38_247_166 c_type)) (forall ((?l1_246_167 c_unique)) (forall ((?l2_245_168 c_unique)) (forall ((?p_244_169 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_38_247_166) ?p_244_169)) (?v_0 (type_pset ?t_38_247_166))) (let ((?v_2 (c_sort ?v_0 ?l2_245_168))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union (c_sort ?v_0 ?l1_246_167) ?v_2))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_40_253_170 c_type)) (forall ((?t_39_252_171 c_type)) (forall ((?l_251_172 c_unique)) (forall ((?m_250_173 c_unique)) (forall ((?p_249_174 c_unique)) (let ((?v_0 (type_pointer ?t_40_253_170))) (=> (forall ((?p1_248_175 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_39_252_171) ?p1_248_175))) (=> (= ?p_249_174 (acc (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_39_252_171) ?l_251_172))))) (not_in_pset (c_sort ?v_0 ?p_249_174) (c_sort (type_pset ?t_40_253_170) (pset_star (c_sort (type_pset ?t_39_252_171) ?l_251_172) (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173)))))))))))) +(assert (forall ((?t_42_259_176 c_type)) (forall ((?t_41_258_177 c_type)) (forall ((?l_257_178 c_unique)) (forall ((?m_256_179 c_unique)) (forall ((?p_255_180 c_unique)) (let ((?v_0 (type_pointer ?t_42_259_176))) (=> (not_in_pset (c_sort ?v_0 ?p_255_180) (c_sort (type_pset ?t_42_259_176) (pset_star (c_sort (type_pset ?t_41_258_177) ?l_257_178) (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179)))) (forall ((?p1_254_181 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_41_258_177) ?p1_254_181))) (=> (= ?p_255_180 (acc (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_41_258_177) ?l_257_178))))))))))))) +(assert (forall ((?t_43_263_182 c_type)) (forall ((?p_262_183 c_unique)) (forall ((?l_261_184 c_unique)) (let ((?v_0 (type_pset ?t_43_263_182))) (=> (forall ((?p1_260_185 c_unique)) (let ((?v_1 (type_pointer ?t_43_263_182))) (let ((?v_2 (c_sort ?v_1 ?p1_260_185))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_261_184))) (not (= (base_addr (c_sort ?v_1 ?p_262_183)) (base_addr ?v_2))))))) (not_in_pset (c_sort (type_pointer ?t_43_263_182) ?p_262_183) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_261_184)))))))))) +(assert (forall ((?t_44_267_186 c_type)) (forall ((?p_266_187 c_unique)) (forall ((?l_265_188 c_unique)) (let ((?v_0 (type_pset ?t_44_267_186))) (=> (not_in_pset (c_sort (type_pointer ?t_44_267_186) ?p_266_187) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_265_188)))) (forall ((?p1_264_189 c_unique)) (let ((?v_1 (type_pointer ?t_44_267_186))) (let ((?v_2 (c_sort ?v_1 ?p1_264_189))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_265_188))) (not (= (base_addr (c_sort ?v_1 ?p_266_187)) (base_addr ?v_2))))))))))))) +(assert (forall ((?t_45_274_190 c_type)) (forall ((?p_273_191 c_unique)) (forall ((?l_272_192 c_unique)) (forall ((?a_271_193 Int)) (forall ((?b_270_194 Int)) (let ((?v_0 (type_pset ?t_45_274_190))) (=> (forall ((?p1_269_195 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) (c_sort ?v_0 ?l_272_192)) (forall ((?i_268_196 Int)) (=> (and (<= ?a_271_193 ?i_268_196) (<= ?i_268_196 ?b_270_194)) (not (= ?p_273_191 (shift (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) ?i_268_196))))))) (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p_273_191) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_272_192) ?a_271_193 ?b_270_194))))))))))) +(assert (forall ((?t_46_281_197 c_type)) (forall ((?p_280_198 c_unique)) (forall ((?l_279_199 c_unique)) (forall ((?a_278_200 Int)) (forall ((?b_277_201 Int)) (let ((?v_0 (type_pset ?t_46_281_197))) (=> (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p_280_198) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_279_199) ?a_278_200 ?b_277_201))) (forall ((?p1_276_202 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) (c_sort ?v_0 ?l_279_199))) (forall ((?i_275_203 Int)) (=> (and (<= ?a_278_200 ?i_275_203) (<= ?i_275_203 ?b_277_201)) (not (= (shift (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) ?i_275_203) ?p_280_198)))))))))))))) +(assert (forall ((?t_47_287_204 c_type)) (forall ((?p_286_205 c_unique)) (forall ((?l_285_206 c_unique)) (forall ((?a_284_207 Int)) (let ((?v_0 (type_pset ?t_47_287_204))) (=> (forall ((?p1_283_208 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) (c_sort ?v_0 ?l_285_206)) (forall ((?i_282_209 Int)) (=> (<= ?i_282_209 ?a_284_207) (not (= ?p_286_205 (shift (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) ?i_282_209))))))) (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p_286_205) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_285_206) ?a_284_207)))))))))) +(assert (forall ((?t_48_293_210 c_type)) (forall ((?p_292_211 c_unique)) (forall ((?l_291_212 c_unique)) (forall ((?a_290_213 Int)) (let ((?v_0 (type_pset ?t_48_293_210))) (=> (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p_292_211) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_291_212) ?a_290_213))) (forall ((?p1_289_214 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) (c_sort ?v_0 ?l_291_212))) (forall ((?i_288_215 Int)) (=> (<= ?i_288_215 ?a_290_213) (not (= (shift (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) ?i_288_215) ?p_292_211))))))))))))) +(assert (forall ((?t_49_299_216 c_type)) (forall ((?p_298_217 c_unique)) (forall ((?l_297_218 c_unique)) (forall ((?a_296_219 Int)) (let ((?v_0 (type_pset ?t_49_299_216))) (=> (forall ((?p1_295_220 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) (c_sort ?v_0 ?l_297_218)) (forall ((?i_294_221 Int)) (=> (<= ?a_296_219 ?i_294_221) (not (= ?p_298_217 (shift (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) ?i_294_221))))))) (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p_298_217) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_297_218) ?a_296_219)))))))))) +(assert (forall ((?t_50_305_222 c_type)) (forall ((?p_304_223 c_unique)) (forall ((?l_303_224 c_unique)) (forall ((?a_302_225 Int)) (let ((?v_0 (type_pset ?t_50_305_222))) (=> (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p_304_223) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_303_224) ?a_302_225))) (forall ((?p1_301_226 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) (c_sort ?v_0 ?l_303_224))) (forall ((?i_300_227 Int)) (=> (<= ?a_302_225 ?i_300_227) (not (= (shift (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) ?i_300_227) ?p_304_223))))))))))))) +(assert (forall ((?t_52_312_228 c_type)) (forall ((?t_51_311_229 c_type)) (forall ((?p_310_230 c_unique)) (forall ((?l_309_231 c_unique)) (forall ((?m_308_232 c_unique)) (let ((?v_0 (type_pointer ?t_51_311_229))) (=> (forall ((?p1_307_233 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_52_312_228) ?p1_307_233) (c_sort (type_pset ?t_52_312_228) ?l_309_231))) (forall ((?i_306_234 Int)) (let ((?v_1 (type_pointer ?t_52_312_228))) (not (= ?p_310_230 (acc (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_307_233) ?i_306_234))))))))) (not_in_pset (c_sort ?v_0 ?p_310_230) (c_sort (type_pset ?t_51_311_229) (pset_acc_all (c_sort (type_pset ?t_52_312_228) ?l_309_231) (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232)))))))))))) +(assert (forall ((?t_54_319_235 c_type)) (forall ((?t_53_318_236 c_type)) (forall ((?p_317_237 c_unique)) (forall ((?l_316_238 c_unique)) (forall ((?m_315_239 c_unique)) (let ((?v_0 (type_pointer ?t_53_318_236))) (=> (not_in_pset (c_sort ?v_0 ?p_317_237) (c_sort (type_pset ?t_53_318_236) (pset_acc_all (c_sort (type_pset ?t_54_319_235) ?l_316_238) (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239)))) (forall ((?p1_314_240 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_54_319_235) ?p1_314_240) (c_sort (type_pset ?t_54_319_235) ?l_316_238))) (forall ((?i_313_241 Int)) (let ((?v_1 (type_pointer ?t_54_319_235))) (not (= (acc (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_314_240) ?i_313_241))) ?p_317_237)))))))))))))) +(assert (forall ((?t_56_328_242 c_type)) (forall ((?t_55_327_243 c_type)) (forall ((?p_326_244 c_unique)) (forall ((?l_325_245 c_unique)) (forall ((?m_324_246 c_unique)) (forall ((?a_323_247 Int)) (forall ((?b_322_248 Int)) (let ((?v_0 (type_pointer ?t_55_327_243))) (=> (forall ((?p1_321_249 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_56_328_242) ?p1_321_249) (c_sort (type_pset ?t_56_328_242) ?l_325_245))) (forall ((?i_320_250 Int)) (let ((?v_1 (type_pointer ?t_56_328_242))) (=> (and (<= ?a_323_247 ?i_320_250) (<= ?i_320_250 ?b_322_248)) (not (= ?p_326_244 (acc (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_321_249) ?i_320_250)))))))))) (not_in_pset (c_sort ?v_0 ?p_326_244) (c_sort (type_pset ?t_55_327_243) (pset_acc_range (c_sort (type_pset ?t_56_328_242) ?l_325_245) (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) ?a_323_247 ?b_322_248))))))))))))) +(assert (forall ((?t_58_337_251 c_type)) (forall ((?t_57_336_252 c_type)) (forall ((?p_335_253 c_unique)) (forall ((?l_334_254 c_unique)) (forall ((?m_333_255 c_unique)) (forall ((?a_332_256 Int)) (forall ((?b_331_257 Int)) (let ((?v_0 (type_pointer ?t_57_336_252))) (=> (not_in_pset (c_sort ?v_0 ?p_335_253) (c_sort (type_pset ?t_57_336_252) (pset_acc_range (c_sort (type_pset ?t_58_337_251) ?l_334_254) (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) ?a_332_256 ?b_331_257))) (forall ((?p1_330_258 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_58_337_251) ?p1_330_258) (c_sort (type_pset ?t_58_337_251) ?l_334_254))) (forall ((?i_329_259 Int)) (let ((?v_1 (type_pointer ?t_58_337_251))) (=> (and (<= ?a_332_256 ?i_329_259) (<= ?i_329_259 ?b_331_257)) (not (= (acc (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_330_258) ?i_329_259))) ?p_335_253))))))))))))))))) +(assert (forall ((?t_60_345_260 c_type)) (forall ((?t_59_344_261 c_type)) (forall ((?p_343_262 c_unique)) (forall ((?l_342_263 c_unique)) (forall ((?m_341_264 c_unique)) (forall ((?a_340_265 Int)) (let ((?v_0 (type_pointer ?t_59_344_261))) (=> (forall ((?p1_339_266 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_60_345_260) ?p1_339_266) (c_sort (type_pset ?t_60_345_260) ?l_342_263))) (forall ((?i_338_267 Int)) (let ((?v_1 (type_pointer ?t_60_345_260))) (=> (<= ?i_338_267 ?a_340_265) (not (= ?p_343_262 (acc (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_339_266) ?i_338_267)))))))))) (not_in_pset (c_sort ?v_0 ?p_343_262) (c_sort (type_pset ?t_59_344_261) (pset_acc_range_left (c_sort (type_pset ?t_60_345_260) ?l_342_263) (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) ?a_340_265)))))))))))) +(assert (forall ((?t_62_353_268 c_type)) (forall ((?t_61_352_269 c_type)) (forall ((?p_351_270 c_unique)) (forall ((?l_350_271 c_unique)) (forall ((?m_349_272 c_unique)) (forall ((?a_348_273 Int)) (let ((?v_0 (type_pointer ?t_61_352_269))) (=> (not_in_pset (c_sort ?v_0 ?p_351_270) (c_sort (type_pset ?t_61_352_269) (pset_acc_range_left (c_sort (type_pset ?t_62_353_268) ?l_350_271) (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) ?a_348_273))) (forall ((?p1_347_274 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_62_353_268) ?p1_347_274) (c_sort (type_pset ?t_62_353_268) ?l_350_271))) (forall ((?i_346_275 Int)) (let ((?v_1 (type_pointer ?t_62_353_268))) (=> (<= ?i_346_275 ?a_348_273) (not (= (acc (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_347_274) ?i_346_275))) ?p_351_270)))))))))))))))) +(assert (forall ((?t_64_361_276 c_type)) (forall ((?t_63_360_277 c_type)) (forall ((?p_359_278 c_unique)) (forall ((?l_358_279 c_unique)) (forall ((?m_357_280 c_unique)) (forall ((?a_356_281 Int)) (let ((?v_0 (type_pointer ?t_63_360_277))) (=> (forall ((?p1_355_282 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_64_361_276) ?p1_355_282) (c_sort (type_pset ?t_64_361_276) ?l_358_279))) (forall ((?i_354_283 Int)) (let ((?v_1 (type_pointer ?t_64_361_276))) (=> (<= ?a_356_281 ?i_354_283) (not (= ?p_359_278 (acc (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_355_282) ?i_354_283)))))))))) (not_in_pset (c_sort ?v_0 ?p_359_278) (c_sort (type_pset ?t_63_360_277) (pset_acc_range_right (c_sort (type_pset ?t_64_361_276) ?l_358_279) (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) ?a_356_281)))))))))))) +(assert (forall ((?t_66_369_284 c_type)) (forall ((?t_65_368_285 c_type)) (forall ((?p_367_286 c_unique)) (forall ((?l_366_287 c_unique)) (forall ((?m_365_288 c_unique)) (forall ((?a_364_289 Int)) (let ((?v_0 (type_pointer ?t_65_368_285))) (=> (not_in_pset (c_sort ?v_0 ?p_367_286) (c_sort (type_pset ?t_65_368_285) (pset_acc_range_right (c_sort (type_pset ?t_66_369_284) ?l_366_287) (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) ?a_364_289))) (forall ((?p1_363_290 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_66_369_284) ?p1_363_290) (c_sort (type_pset ?t_66_369_284) ?l_366_287))) (forall ((?i_362_291 Int)) (let ((?v_1 (type_pointer ?t_66_369_284))) (=> (<= ?a_364_289 ?i_362_291) (not (= (acc (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_363_290) ?i_362_291))) ?p_367_286)))))))))))))))) +(assert (forall ((?t_68_376_292 c_type)) (forall ((?t_67_375_293 c_type)) (forall ((?a_374_294 c_unique)) (forall ((?l_373_295 c_unique)) (forall ((?m1_372_296 c_unique)) (forall ((?m2_371_297 c_unique)) (forall ((?m3_370_298 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a_374_294)) (?v_0 (type_memory ?t_68_376_292 ?t_67_375_293))) (let ((?v_4 (c_sort ?v_0 ?m1_372_296)) (?v_2 (c_sort ?v_0 ?m2_371_297)) (?v_3 (c_sort (type_pset ?t_67_375_293) ?l_373_295)) (?v_5 (c_sort ?v_0 ?m3_370_298))) (=> (not_assigns ?v_1 ?v_4 ?v_2 ?v_3) (=> (not_assigns ?v_1 ?v_2 ?v_5 ?v_3) (not_assigns ?v_1 ?v_4 ?v_5 ?v_3))))))))))))) +(assert (forall ((?t_70_381_299 c_type)) (forall ((?t_69_380_300 c_type)) (forall ((?a_379_301 c_unique)) (forall ((?l_378_302 c_unique)) (forall ((?m_377_303 c_unique)) (let ((?v_0 (c_sort (type_memory ?t_70_381_299 ?t_69_380_300) ?m_377_303))) (not_assigns (c_sort type_alloc_table ?a_379_301) ?v_0 ?v_0 (c_sort (type_pset ?t_69_380_300) ?l_378_302))))))))) +(declare-fun valid_acc (c_ssorted) Bool) +(assert (forall ((?t_72_386_304 c_type)) (forall ((?t_71_385_305 c_type)) (forall ((?m1_384_306 c_unique)) (= (valid_acc (c_sort (type_memory (type_pointer ?t_71_385_305) ?t_72_386_304) ?m1_384_306)) (forall ((?p_383_307 c_unique)) (forall ((?a_382_308 c_unique)) (let ((?v_1 (type_pointer ?t_71_385_305)) (?v_0 (c_sort type_alloc_table ?a_382_308)) (?v_2 (c_sort (type_pointer ?t_72_386_304) ?p_383_307))) (=> (valid ?v_0 ?v_2) (valid ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_72_386_304) ?m1_384_306) ?v_2)))))))))))) +(declare-fun valid_acc_range (c_ssorted Int) Bool) +(assert (forall ((?t_74_392_309 c_type)) (forall ((?t_73_391_310 c_type)) (forall ((?m1_390_311 c_unique)) (forall ((?size_389_312 Int)) (= (valid_acc_range (c_sort (type_memory (type_pointer ?t_73_391_310) ?t_74_392_309) ?m1_390_311) ?size_389_312) (forall ((?p_388_313 c_unique)) (forall ((?a_387_314 c_unique)) (let ((?v_1 (type_pointer ?t_73_391_310)) (?v_0 (c_sort type_alloc_table ?a_387_314)) (?v_2 (c_sort (type_pointer ?t_74_392_309) ?p_388_313))) (=> (valid ?v_0 ?v_2) (valid_range ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_74_392_309) ?m1_390_311) ?v_2)) 0 (- ?size_389_312 1)))))))))))) +(assert (forall ((?t_76_398_315 c_type)) (forall ((?t_75_397_316 c_type)) (forall ((?m1_396_317 c_unique)) (forall ((?size_395_318 Int)) (forall ((?p_394_319 c_unique)) (forall ((?a_393_320 c_unique)) (let ((?v_1 (type_pointer ?t_75_397_316))) (let ((?v_2 (c_sort (type_memory ?v_1 ?t_76_398_315) ?m1_396_317)) (?v_0 (c_sort type_alloc_table ?a_393_320)) (?v_3 (c_sort (type_pointer ?t_76_398_315) ?p_394_319))) (=> (valid_acc_range ?v_2 ?size_395_318) (=> (valid ?v_0 ?v_3) (valid ?v_0 (c_sort ?v_1 (acc ?v_2 ?v_3)))))))))))))) +(declare-fun separation1 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_78_404_321 c_type)) (forall ((?t_77_403_322 c_type)) (forall ((?m1_402_323 c_unique)) (forall ((?m2_401_324 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_77_403_322) ?t_78_404_321))) (= (separation1 (c_sort ?v_0 ?m1_402_323) (c_sort ?v_0 ?m2_401_324)) (forall ((?p_400_325 c_unique)) (forall ((?a_399_326 c_unique)) (let ((?v_1 (type_pointer ?t_77_403_322)) (?v_2 (c_sort (type_pointer ?t_78_404_321) ?p_400_325))) (=> (valid (c_sort type_alloc_table ?a_399_326) ?v_2) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_402_323) ?v_2))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_401_324) ?v_2)))))))))))))))) +(declare-fun separation1_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_80_412_327 c_type)) (forall ((?t_79_411_328 c_type)) (forall ((?m1_410_329 c_unique)) (forall ((?m2_409_330 c_unique)) (forall ((?size_408_331 Int)) (let ((?v_0 (type_memory (type_pointer ?t_79_411_328) ?t_80_412_327))) (= (separation1_range1 (c_sort ?v_0 ?m1_410_329) (c_sort ?v_0 ?m2_409_330) ?size_408_331) (forall ((?p_407_332 c_unique)) (forall ((?a_406_333 c_unique)) (=> (valid (c_sort type_alloc_table ?a_406_333) (c_sort (type_pointer ?t_80_412_327) ?p_407_332)) (forall ((?i_405_334 Int)) (let ((?v_1 (type_pointer ?t_79_411_328)) (?v_2 (type_pointer ?t_80_412_327))) (let ((?v_3 (c_sort ?v_2 ?p_407_332))) (=> (and (<= 0 ?i_405_334) (< ?i_405_334 ?size_408_331)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_410_329) (c_sort ?v_2 (shift ?v_3 ?i_405_334))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_409_330) ?v_3)))))))))))))))))))) +(declare-fun separation1_range (c_ssorted Int) Bool) +(assert (forall ((?t_82_420_335 c_type)) (forall ((?t_81_419_336 c_type)) (forall ((?m_418_337 c_unique)) (forall ((?size_417_338 Int)) (= (separation1_range (c_sort (type_memory (type_pointer ?t_81_419_336) ?t_82_420_335) ?m_418_337) ?size_417_338) (forall ((?p_416_339 c_unique)) (forall ((?a_415_340 c_unique)) (=> (valid (c_sort type_alloc_table ?a_415_340) (c_sort (type_pointer ?t_82_420_335) ?p_416_339)) (forall ((?i1_414_341 Int)) (forall ((?i2_413_342 Int)) (let ((?v_0 (type_pointer ?t_81_419_336))) (let ((?v_2 (c_sort (type_memory ?v_0 ?t_82_420_335) ?m_418_337)) (?v_1 (type_pointer ?t_82_420_335))) (let ((?v_3 (c_sort ?v_1 ?p_416_339))) (=> (and (<= 0 ?i1_414_341) (< ?i1_414_341 ?size_417_338)) (=> (and (<= 0 ?i2_413_342) (< ?i2_413_342 ?size_417_338)) (=> (not (= ?i1_414_341 ?i2_413_342)) (not (= (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i1_414_341))))) (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i2_413_342)))))))))))))))))))))))) +(declare-fun separation2 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_84_426_343 c_type)) (forall ((?t_83_425_344 c_type)) (forall ((?m1_424_345 c_unique)) (forall ((?m2_423_346 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_83_425_344) ?t_84_426_343))) (= (separation2 (c_sort ?v_0 ?m1_424_345) (c_sort ?v_0 ?m2_423_346)) (forall ((?p1_422_347 c_unique)) (forall ((?p2_421_348 c_unique)) (let ((?v_1 (type_pointer ?t_83_425_344)) (?v_2 (type_pointer ?t_84_426_343))) (=> (not (= ?p1_422_347 ?p2_421_348)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_424_345) (c_sort ?v_2 ?p1_422_347)))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_423_346) (c_sort ?v_2 ?p2_421_348))))))))))))))))) +(declare-fun separation2_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_86_435_349 c_type)) (forall ((?t_85_434_350 c_type)) (forall ((?m1_433_351 c_unique)) (forall ((?m2_432_352 c_unique)) (forall ((?size_431_353 Int)) (let ((?v_0 (type_memory (type_pointer ?t_85_434_350) ?t_86_435_349))) (= (separation2_range1 (c_sort ?v_0 ?m1_433_351) (c_sort ?v_0 ?m2_432_352) ?size_431_353) (forall ((?p_430_354 c_unique)) (forall ((?q_429_355 c_unique)) (forall ((?a_428_356 c_unique)) (forall ((?i_427_357 Int)) (let ((?v_1 (type_pointer ?t_85_434_350)) (?v_2 (type_pointer ?t_86_435_349))) (=> (and (<= 0 ?i_427_357) (< ?i_427_357 ?size_431_353)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_433_351) (c_sort ?v_2 (shift (c_sort ?v_2 ?p_430_354) ?i_427_357))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_432_352) (c_sort ?v_2 ?q_429_355)))))))))))))))))))) +(declare-fun on_heap (c_ssorted c_ssorted) Bool) +(declare-fun on_stack (c_ssorted c_ssorted) Bool) +(declare-fun fresh (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_87_438_358 c_type)) (forall ((?a_437_359 c_unique)) (forall ((?p_436_360 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_437_359)) (?v_1 (c_sort (type_pointer ?t_87_438_358) ?p_436_360))) (=> (fresh ?v_0 ?v_1) (not (valid ?v_0 ?v_1)))))))) +(assert (forall ((?t_88_442_361 c_type)) (forall ((?a_441_362 c_unique)) (forall ((?p_440_363 c_unique)) (=> (fresh (c_sort type_alloc_table ?a_441_362) (c_sort (type_pointer ?t_88_442_361) ?p_440_363)) (forall ((?i_439_364 Int)) (let ((?v_0 (type_pointer ?t_88_442_361))) (not (valid (c_sort type_alloc_table ?a_441_362) (c_sort ?v_0 (shift (c_sort ?v_0 ?p_440_363) ?i_439_364))))))))))) +(declare-fun alloc_extends (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_89_446_365 c_type)) (forall ((?a1_445_366 c_unique)) (forall ((?a2_444_367 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_445_366) (c_sort type_alloc_table ?a2_444_367)) (forall ((?q_443_368 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_89_446_365) ?q_443_368))) (=> (valid (c_sort type_alloc_table ?a1_445_366) ?v_0) (valid (c_sort type_alloc_table ?a2_444_367) ?v_0))))))))) +(assert (forall ((?t_90_451_369 c_type)) (forall ((?a1_450_370 c_unique)) (forall ((?a2_449_371 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_450_370) (c_sort type_alloc_table ?a2_449_371)) (forall ((?q_448_372 c_unique)) (forall ((?i_447_373 Int)) (let ((?v_0 (c_sort (type_pointer ?t_90_451_369) ?q_448_372))) (=> (valid_index (c_sort type_alloc_table ?a1_450_370) ?v_0 ?i_447_373) (valid_index (c_sort type_alloc_table ?a2_449_371) ?v_0 ?i_447_373)))))))))) +(assert (forall ((?t_91_457_374 c_type)) (forall ((?a1_456_375 c_unique)) (forall ((?a2_455_376 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_456_375) (c_sort type_alloc_table ?a2_455_376)) (forall ((?q_454_377 c_unique)) (forall ((?i_453_378 Int)) (forall ((?j_452_379 Int)) (let ((?v_0 (c_sort (type_pointer ?t_91_457_374) ?q_454_377))) (=> (valid_range (c_sort type_alloc_table ?a1_456_375) ?v_0 ?i_453_378 ?j_452_379) (valid_range (c_sort type_alloc_table ?a2_455_376) ?v_0 ?i_453_378 ?j_452_379))))))))))) +(assert (forall ((?a_458_380 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_458_380))) (alloc_extends ?v_0 ?v_0)))) +(assert (forall ((?a1_461_381 c_unique)) (forall ((?a2_460_382 c_unique)) (forall ((?a3_459_383 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a1_461_381)) (?v_0 (c_sort type_alloc_table ?a2_460_382)) (?v_2 (c_sort type_alloc_table ?a3_459_383))) (=> (alloc_extends ?v_1 ?v_0) (=> (alloc_extends ?v_0 ?v_2) (alloc_extends ?v_1 ?v_2)))))))) +(declare-fun free_stack (c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_92_466_384 c_type)) (forall ((?a1_465_385 c_unique)) (forall ((?a2_464_386 c_unique)) (forall ((?a3_463_387 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_465_385) (c_sort type_alloc_table ?a2_464_386) (c_sort type_alloc_table ?a3_463_387)) (forall ((?p_462_388 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a2_464_386)) (?v_1 (c_sort (type_pointer ?t_92_466_384) ?p_462_388))) (=> (valid ?v_0 ?v_1) (=> (on_heap ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_463_387) ?v_1))))))))))) +(assert (forall ((?t_93_471_389 c_type)) (forall ((?a1_470_390 c_unique)) (forall ((?a2_469_391 c_unique)) (forall ((?a3_468_392 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_470_390) (c_sort type_alloc_table ?a2_469_391) (c_sort type_alloc_table ?a3_468_392)) (forall ((?p_467_393 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a1_470_390)) (?v_1 (c_sort (type_pointer ?t_93_471_389) ?p_467_393))) (=> (valid ?v_0 ?v_1) (=> (on_stack ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_468_392) ?v_1))))))))))) +(declare-fun null () c_unique) +(assert (forall ((?t_94_475_394 c_type)) (forall ((?a_474_395 c_unique)) (not (valid (c_sort type_alloc_table ?a_474_395) (c_sort (type_pointer ?t_94_475_394) null)))))) +(declare-fun type_global () c_type) +(assert (not (forall ((?t c_unique)) (forall ((?n Int)) (forall ((?alloc c_unique)) (forall ((?intM_global c_unique)) (=> (valid_range (c_sort type_alloc_table ?alloc) (c_sort (type_pointer type_global) ?t) 0 ?n) (forall ((?mutable_n Int)) (=> (and (<= ?mutable_n ?n) (forall ((?i_495_419 Int)) (let ((?v_0 (type_pointer type_global))) (=> (and (<= ?mutable_n ?i_495_419) (< ?i_495_419 ?n)) (= (ss2Int (c_sort c_int (acc (c_sort (type_memory c_int type_global) ?intM_global) (c_sort ?v_0 (shift (c_sort ?v_0 ?t) ?i_495_419))))) 0))))) (forall ((?mutable_n0 Int)) (=> (= ?mutable_n0 (- ?mutable_n 1)) (=> (< ?mutable_n0 0) (=> (not (= 1 0)) (forall ((?i Int)) (let ((?v_1 (type_pointer type_global))) (=> (and (<= 0 ?i) (< ?i ?n)) (= (ss2Int (c_sort c_int (acc (c_sort (type_memory c_int type_global) ?intM_global) (c_sort ?v_1 (shift (c_sort ?v_1 ?t) ?i))))) 0))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/smtlib46f14a.smt2 b/test/regress/regress1/quantifiers/smtlib46f14a.smt2 new file mode 100644 index 000000000..fa0c85470 --- /dev/null +++ b/test/regress/regress1/quantifiers/smtlib46f14a.smt2 @@ -0,0 +1,205 @@ +(set-logic AUFLIRA) +(set-info :source |http://proval.lri.fr/why-benchmarks |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-sort Unit 0) +(declare-sort c_unique 0) +(declare-sort c_ssorted 0) +(declare-sort c_type 0) +(declare-sort c_Boolean 0) +(declare-fun c_sort (c_type c_unique) c_ssorted) +(declare-fun c_Boolean_true () c_Boolean) +(declare-fun c_Boolean_false () c_Boolean) +(assert (forall ((?b_22_1 c_Boolean)) (or (= c_Boolean_true ?b_22_1) (= c_Boolean_false ?b_22_1)))) +(assert (not (= c_Boolean_true c_Boolean_false))) +(declare-fun int2U (Int) c_unique) +(declare-fun ss2Int (c_ssorted) Int) +(declare-fun real2U (Real) c_unique) +(declare-fun ss2Real (c_ssorted) Real) +(declare-fun bool2U (c_Boolean) c_unique) +(declare-fun ss2Bool (c_ssorted) c_Boolean) +(declare-fun c_int () c_type) +(declare-fun c_bool () c_type) +(declare-fun c_real () c_type) +(declare-fun c_unit () c_type) +(declare-fun c_ref (c_unique) c_unique) +(assert (forall ((?t_21_2 c_type)) (forall ((?x_20_3 c_unique)) (forall ((?y_19_4 c_unique)) (=> (= (c_sort ?t_21_2 ?x_20_3) (c_sort ?t_21_2 ?y_19_4)) (= ?x_20_3 ?y_19_4)))))) +(assert (forall ((?x_18_5 Int)) (= (ss2Int (c_sort c_int (int2U ?x_18_5))) ?x_18_5))) +(assert (forall ((?x_17_6 Int)) (forall ((?y_16_7 Int)) (=> (= (int2U ?x_17_6) (int2U ?y_16_7)) (= ?x_17_6 ?y_16_7))))) +(assert (forall ((?x_15_8 Real)) (forall ((?y_14_9 Real)) (=> (= (real2U ?x_15_8) (real2U ?y_14_9)) (= ?x_15_8 ?y_14_9))))) +(assert (forall ((?x_13_10 c_Boolean)) (forall ((?y_12_11 c_Boolean)) (=> (= (bool2U ?x_13_10) (bool2U ?y_12_11)) (= ?x_13_10 ?y_12_11))))) +(assert (forall ((?x_11_12 c_ssorted)) (forall ((?y_10_13 c_ssorted)) (=> (= (ss2Int ?x_11_12) (ss2Int ?y_10_13)) (= ?x_11_12 ?y_10_13))))) +(assert (forall ((?x_9_14 c_ssorted)) (forall ((?y_8_15 c_ssorted)) (=> (= (ss2Real ?x_9_14) (ss2Real ?y_8_15)) (= ?x_9_14 ?y_8_15))))) +(assert (forall ((?x_7_16 c_ssorted)) (forall ((?y_6_17 c_ssorted)) (=> (= (ss2Bool ?x_7_16) (ss2Bool ?y_6_17)) (= ?x_7_16 ?y_6_17))))) +(assert (forall ((?x_5_18 Real)) (= (ss2Real (c_sort c_real (real2U ?x_5_18))) ?x_5_18))) +(assert (forall ((?x_4_19 c_Boolean)) (= (ss2Bool (c_sort c_bool (bool2U ?x_4_19))) ?x_4_19))) +(assert (forall ((?x_3_20 c_unique)) (= (int2U (ss2Int (c_sort c_int ?x_3_20))) ?x_3_20))) +(assert (forall ((?x_2_21 c_unique)) (= (real2U (ss2Real (c_sort c_real ?x_2_21))) ?x_2_21))) +(assert (forall ((?x_1_22 c_unique)) (= (bool2U (ss2Bool (c_sort c_bool ?x_1_22))) ?x_1_22))) +(declare-fun eq_int (Int Int) Bool) +(declare-fun neq_int (Int Int) Bool) +(declare-fun lt_int_bool (Int Int) c_Boolean) +(declare-fun le_int_bool (Int Int) c_Boolean) +(declare-fun gt_int_bool (Int Int) c_Boolean) +(declare-fun ge_int_bool (Int Int) c_Boolean) +(declare-fun eq_int_bool (Int Int) c_Boolean) +(declare-fun neq_int_bool (Int Int) c_Boolean) +(assert (forall ((?x_40_23 Int)) (forall ((?y_39_24 Int)) (= (= (lt_int_bool ?x_40_23 ?y_39_24) c_Boolean_true) (< ?x_40_23 ?y_39_24))))) +(assert (forall ((?x_42_25 Int)) (forall ((?y_41_26 Int)) (= (= (le_int_bool ?x_42_25 ?y_41_26) c_Boolean_true) (<= ?x_42_25 ?y_41_26))))) +(assert (forall ((?x_44_27 Int)) (forall ((?y_43_28 Int)) (= (= (gt_int_bool ?x_44_27 ?y_43_28) c_Boolean_true) (> ?x_44_27 ?y_43_28))))) +(assert (forall ((?x_46_29 Int)) (forall ((?y_45_30 Int)) (= (= (ge_int_bool ?x_46_29 ?y_45_30) c_Boolean_true) (>= ?x_46_29 ?y_45_30))))) +(assert (forall ((?x_48_31 Int)) (forall ((?y_47_32 Int)) (= (= (eq_int_bool ?x_48_31 ?y_47_32) c_Boolean_true) (= ?x_48_31 ?y_47_32))))) +(assert (forall ((?x_50_33 Int)) (forall ((?y_49_34 Int)) (= (= (neq_int_bool ?x_50_33 ?y_49_34) c_Boolean_true) (not (= ?x_50_33 ?y_49_34)))))) +(declare-fun add_real (Real Real) Real) +(declare-fun sub_real (Real Real) Real) +(declare-fun mul_real (Real Real) Real) +(declare-fun div_real (Real Real) Real) +(declare-fun pow_real (Real Real) Real) +(declare-fun neg_real (Real) Real) +(declare-fun abs_real (Real) Real) +(declare-fun sqrt_real (Real) Real) +(declare-fun real_of_int (Int) Real) +(declare-fun int_of_real (Real) Int) +(declare-fun lt_real (Real Real) Bool) +(declare-fun le_real (Real Real) Bool) +(declare-fun gt_real (Real Real) Bool) +(declare-fun ge_real (Real Real) Bool) +(declare-fun eq_real (Real Real) Bool) +(declare-fun neq_real (Real Real) Bool) +(declare-fun eq_bool (c_Boolean c_Boolean) Bool) +(declare-fun neq_bool (c_Boolean c_Boolean) Bool) +(declare-fun eq_unit (c_ssorted c_ssorted) Bool) +(declare-fun neq_unit (c_ssorted c_ssorted) Bool) +(declare-fun smtlib__ite (c_Boolean c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_1_76_35 c_type)) (forall ((?x_75_36 c_unique)) (forall ((?y_74_37 c_unique)) (= (smtlib__ite c_Boolean_true (c_sort ?t_1_76_35 ?x_75_36) (c_sort ?t_1_76_35 ?y_74_37)) ?x_75_36))))) +(assert (forall ((?t_2_79_38 c_type)) (forall ((?x_78_39 c_unique)) (forall ((?y_77_40 c_unique)) (= (smtlib__ite c_Boolean_false (c_sort ?t_2_79_38 ?x_78_39) (c_sort ?t_2_79_38 ?y_77_40)) ?y_77_40))))) +(declare-fun bw_compl (Int) Int) +(declare-fun bw_and (Int Int) Int) +(declare-fun bw_xor (Int Int) Int) +(declare-fun bw_or (Int Int) Int) +(declare-fun lsl (Int Int) Int) +(declare-fun lsr (Int Int) Int) +(declare-fun non_int (Int) Int) +(declare-fun type_pointer (c_type) c_type) +(declare-fun type_addr (c_type) c_type) +(declare-fun type_alloc_table () c_type) +(declare-fun block_length (c_ssorted c_ssorted) Int) +(declare-fun base_addr (c_ssorted) c_unique) +(declare-fun offset (c_ssorted) Int) +(declare-fun shift (c_ssorted Int) c_unique) +(declare-fun sub_pointer (c_ssorted c_ssorted) Int) +(declare-fun lt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_3_88_41 c_type)) (forall ((?p1_87_42 c_unique)) (forall ((?p2_86_43 c_unique)) (let ((?v_0 (type_pointer ?t_3_88_41))) (let ((?v_1 (c_sort ?v_0 ?p1_87_42)) (?v_2 (c_sort ?v_0 ?p2_86_43))) (= (lt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (< (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun le_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_4_91_44 c_type)) (forall ((?p1_90_45 c_unique)) (forall ((?p2_89_46 c_unique)) (let ((?v_0 (type_pointer ?t_4_91_44))) (let ((?v_1 (c_sort ?v_0 ?p1_90_45)) (?v_2 (c_sort ?v_0 ?p2_89_46))) (= (le_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (<= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun gt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_5_94_47 c_type)) (forall ((?p1_93_48 c_unique)) (forall ((?p2_92_49 c_unique)) (let ((?v_0 (type_pointer ?t_5_94_47))) (let ((?v_1 (c_sort ?v_0 ?p1_93_48)) (?v_2 (c_sort ?v_0 ?p2_92_49))) (= (gt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (> (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun ge_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_6_97_50 c_type)) (forall ((?p1_96_51 c_unique)) (forall ((?p2_95_52 c_unique)) (let ((?v_0 (type_pointer ?t_6_97_50))) (let ((?v_1 (c_sort ?v_0 ?p1_96_51)) (?v_2 (c_sort ?v_0 ?p2_95_52))) (= (ge_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (>= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun valid (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_7_104_53 c_type)) (forall ((?a_103_54 c_unique)) (forall ((?p_102_55 c_unique)) (let ((?v_2 (c_sort type_alloc_table ?a_103_54)) (?v_0 (c_sort (type_pointer ?t_7_104_53) ?p_102_55))) (let ((?v_1 (offset ?v_0))) (= (valid ?v_2 ?v_0) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0)))))))))) +(declare-fun valid_index (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_8_108_56 c_type)) (forall ((?a_107_57 c_unique)) (forall ((?p_106_58 c_unique)) (forall ((?i_105_59 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_107_57)) (?v_0 (c_sort (type_pointer ?t_8_108_56) ?p_106_58))) (let ((?v_1 (+ (offset ?v_0) ?i_105_59))) (= (valid_index ?v_2 ?v_0 ?i_105_59) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0))))))))))) +(declare-fun valid_range (c_ssorted c_ssorted Int Int) Bool) +(assert (forall ((?t_9_113_60 c_type)) (forall ((?a_112_61 c_unique)) (forall ((?p_111_62 c_unique)) (forall ((?i_110_63 Int)) (forall ((?j_109_64 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_112_61)) (?v_0 (c_sort (type_pointer ?t_9_113_60) ?p_111_62))) (let ((?v_1 (offset ?v_0))) (= (valid_range ?v_2 ?v_0 ?i_110_63 ?j_109_64) (and (<= 0 (+ ?v_1 ?i_110_63)) (< (+ ?v_1 ?j_109_64) (block_length ?v_2 ?v_0)))))))))))) +(assert (forall ((?t_10_116_65 c_type)) (forall ((?p_115_66 c_unique)) (forall ((?i_114_67 Int)) (let ((?v_0 (type_pointer ?t_10_116_65))) (let ((?v_1 (c_sort ?v_0 ?p_115_66))) (= (offset (c_sort ?v_0 (shift ?v_1 ?i_114_67))) (+ (offset ?v_1) ?i_114_67)))))))) +(assert (forall ((?t_11_118_68 c_type)) (forall ((?p_117_69 c_unique)) (= (shift (c_sort (type_pointer ?t_11_118_68) ?p_117_69) 0) ?p_117_69)))) +(assert (forall ((?t_12_122_70 c_type)) (forall ((?p_121_71 c_unique)) (forall ((?i_120_72 Int)) (forall ((?j_119_73 Int)) (let ((?v_0 (type_pointer ?t_12_122_70))) (let ((?v_1 (c_sort ?v_0 ?p_121_71))) (= (shift (c_sort ?v_0 (shift ?v_1 ?i_120_72)) ?j_119_73) (shift ?v_1 (+ ?i_120_72 ?j_119_73)))))))))) +(assert (forall ((?t_13_125_74 c_type)) (forall ((?p_124_75 c_unique)) (forall ((?i_123_76 Int)) (let ((?v_0 (type_pointer ?t_13_125_74))) (let ((?v_1 (c_sort ?v_0 ?p_124_75))) (= (base_addr (c_sort ?v_0 (shift ?v_1 ?i_123_76))) (base_addr ?v_1)))))))) +(assert (forall ((?t_14_129_77 c_type)) (forall ((?a_128_78 c_unique)) (forall ((?p_127_79 c_unique)) (forall ((?i_126_80 Int)) (let ((?v_1 (c_sort type_alloc_table ?a_128_78)) (?v_0 (type_pointer ?t_14_129_77))) (let ((?v_2 (c_sort ?v_0 ?p_127_79))) (= (block_length ?v_1 (c_sort ?v_0 (shift ?v_2 ?i_126_80))) (block_length ?v_1 ?v_2))))))))) +(assert (forall ((?t_15_133_81 c_type)) (forall ((?a_132_82 c_unique)) (forall ((?p1_131_83 c_unique)) (forall ((?p2_130_84 c_unique)) (let ((?v_0 (type_pointer ?t_15_133_81))) (let ((?v_1 (c_sort ?v_0 ?p1_131_83)) (?v_3 (c_sort ?v_0 ?p2_130_84)) (?v_2 (c_sort type_alloc_table ?a_132_82))) (=> (= (base_addr ?v_1) (base_addr ?v_3)) (= (block_length ?v_2 ?v_1) (block_length ?v_2 ?v_3)))))))))) +(assert (forall ((?t_16_136_85 c_type)) (forall ((?p1_135_86 c_unique)) (forall ((?p2_134_87 c_unique)) (let ((?v_0 (type_pointer ?t_16_136_85))) (let ((?v_1 (c_sort ?v_0 ?p1_135_86)) (?v_2 (c_sort ?v_0 ?p2_134_87))) (=> (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2))) (= ?p1_135_86 ?p2_134_87)))))))) +(assert (forall ((?t_17_139_88 c_type)) (forall ((?p1_138_89 c_unique)) (forall ((?p2_137_90 c_unique)) (let ((?v_0 (type_pointer ?t_17_139_88))) (let ((?v_1 (c_sort ?v_0 ?p1_138_89)) (?v_2 (c_sort ?v_0 ?p2_137_90))) (=> (= ?p1_138_89 ?p2_137_90) (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2)))))))))) +(assert (forall ((?t_18_144_91 c_type)) (forall ((?p1_143_92 c_unique)) (forall ((?p2_142_93 c_unique)) (forall ((?i_141_94 Int)) (forall ((?j_140_95 Int)) (let ((?v_0 (type_pointer ?t_18_144_91))) (let ((?v_1 (c_sort ?v_0 ?p1_143_92)) (?v_2 (c_sort ?v_0 ?p2_142_93))) (=> (not (= (base_addr ?v_1) (base_addr ?v_2))) (not (= (shift ?v_1 ?i_141_94) (shift ?v_2 ?j_140_95)))))))))))) +(assert (forall ((?t_19_149_96 c_type)) (forall ((?p1_148_97 c_unique)) (forall ((?p2_147_98 c_unique)) (forall ((?i_146_99 Int)) (forall ((?j_145_100 Int)) (let ((?v_0 (type_pointer ?t_19_149_96))) (let ((?v_1 (c_sort ?v_0 ?p1_148_97)) (?v_2 (c_sort ?v_0 ?p2_147_98))) (=> (not (= (+ (offset ?v_1) ?i_146_99) (+ (offset ?v_2) ?j_145_100))) (not (= (shift ?v_1 ?i_146_99) (shift ?v_2 ?j_145_100)))))))))))) +(assert (forall ((?t_20_154_101 c_type)) (forall ((?p1_153_102 c_unique)) (forall ((?p2_152_103 c_unique)) (forall ((?i_151_104 Int)) (forall ((?j_150_105 Int)) (let ((?v_0 (type_pointer ?t_20_154_101))) (let ((?v_1 (c_sort ?v_0 ?p1_153_102)) (?v_2 (c_sort ?v_0 ?p2_152_103))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (=> (= (+ (offset ?v_1) ?i_151_104) (+ (offset ?v_2) ?j_150_105)) (= (shift ?v_1 ?i_151_104) (shift ?v_2 ?j_150_105)))))))))))) +(assert (forall ((?t_21_158_106 c_type)) (forall ((?a_157_107 c_unique)) (forall ((?p_156_108 c_unique)) (forall ((?i_155_109 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_157_107)) (?v_1 (type_pointer ?t_21_158_106))) (let ((?v_2 (c_sort ?v_1 ?p_156_108))) (=> (valid_index ?v_0 ?v_2 ?i_155_109) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?i_155_109))))))))))) +(assert (forall ((?t_22_164_110 c_type)) (forall ((?a_163_111 c_unique)) (forall ((?p_162_112 c_unique)) (forall ((?i_161_113 Int)) (forall ((?j_160_114 Int)) (forall ((?k_159_115 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_163_111)) (?v_1 (type_pointer ?t_22_164_110))) (let ((?v_2 (c_sort ?v_1 ?p_162_112))) (=> (valid_range ?v_0 ?v_2 ?i_161_113 ?j_160_114) (=> (and (<= ?i_161_113 ?k_159_115) (<= ?k_159_115 ?j_160_114)) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?k_159_115)))))))))))))) +(assert (forall ((?t_23_169_116 c_type)) (forall ((?a_168_117 c_unique)) (forall ((?p_167_118 c_unique)) (forall ((?i_166_119 Int)) (forall ((?j_165_120 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_168_117)) (?v_1 (c_sort (type_pointer ?t_23_169_116) ?p_167_118))) (=> (valid_range ?v_0 ?v_1 ?i_166_119 ?j_165_120) (=> (and (<= ?i_166_119 0) (<= 0 ?j_165_120)) (valid ?v_0 ?v_1)))))))))) +(assert (forall ((?t_24_175_121 c_type)) (forall ((?a_174_122 c_unique)) (forall ((?p_173_123 c_unique)) (forall ((?i_172_124 Int)) (forall ((?j_171_125 Int)) (forall ((?k_170_126 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_174_122)) (?v_1 (c_sort (type_pointer ?t_24_175_121) ?p_173_123))) (=> (valid_range ?v_0 ?v_1 ?i_172_124 ?j_171_125) (=> (and (<= ?i_172_124 ?k_170_126) (<= ?k_170_126 ?j_171_125)) (valid_index ?v_0 ?v_1 ?k_170_126))))))))))) +(assert (forall ((?t_25_178_127 c_type)) (forall ((?p1_177_128 c_unique)) (forall ((?p2_176_129 c_unique)) (let ((?v_0 (type_pointer ?t_25_178_127))) (let ((?v_1 (c_sort ?v_0 ?p1_177_128)) (?v_2 (c_sort ?v_0 ?p2_176_129))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (= (sub_pointer ?v_1 ?v_2) (- (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun type_memory (c_type c_type) c_type) +(declare-fun acc (c_ssorted c_ssorted) c_unique) +(declare-fun upd (c_ssorted c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_27_212_130 c_type)) (forall ((?t_26_211_131 c_type)) (forall ((?m_210_132 c_unique)) (forall ((?p_209_133 c_unique)) (forall ((?a_208_134 c_unique)) (let ((?v_0 (type_memory ?t_26_211_131 ?t_27_212_130)) (?v_1 (c_sort (type_pointer ?t_27_212_130) ?p_209_133))) (= (acc (c_sort ?v_0 (upd (c_sort ?v_0 ?m_210_132) ?v_1 (c_sort ?t_26_211_131 ?a_208_134))) ?v_1) ?a_208_134)))))))) +(assert (forall ((?t_29_218_135 c_type)) (forall ((?t_28_217_136 c_type)) (forall ((?m_216_137 c_unique)) (forall ((?p1_215_138 c_unique)) (forall ((?p2_214_139 c_unique)) (forall ((?a_213_140 c_unique)) (let ((?v_0 (type_memory ?t_28_217_136 ?t_29_218_135))) (let ((?v_2 (c_sort ?v_0 ?m_216_137)) (?v_1 (type_pointer ?t_29_218_135))) (let ((?v_3 (c_sort ?v_1 ?p2_214_139))) (=> (not (= ?p1_215_138 ?p2_214_139)) (= (acc (c_sort ?v_0 (upd ?v_2 (c_sort ?v_1 ?p1_215_138) (c_sort ?t_28_217_136 ?a_213_140))) ?v_3) (acc ?v_2 ?v_3))))))))))))) +(assert (not (= c_Boolean_false c_Boolean_true))) +(declare-fun type_pset (c_type) c_type) +(declare-fun pset_empty () c_unique) +(declare-fun pset_singleton (c_ssorted) c_unique) +(declare-fun pset_star (c_ssorted c_ssorted) c_unique) +(declare-fun pset_all (c_ssorted) c_unique) +(declare-fun pset_range (c_ssorted Int Int) c_unique) +(declare-fun pset_range_left (c_ssorted Int) c_unique) +(declare-fun pset_range_right (c_ssorted Int) c_unique) +(declare-fun pset_acc_all (c_ssorted c_ssorted) c_unique) +(declare-fun pset_acc_range (c_ssorted c_ssorted Int Int) c_unique) +(declare-fun pset_acc_range_left (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_acc_range_right (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_union (c_ssorted c_ssorted) c_unique) +(declare-fun not_in_pset (c_ssorted c_ssorted) Bool) +(declare-fun not_assigns (c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_31_225_141 c_type)) (forall ((?t_30_224_142 c_type)) (forall ((?a_223_143 c_unique)) (forall ((?m1_222_144 c_unique)) (forall ((?m2_221_145 c_unique)) (forall ((?l_220_146 c_unique)) (let ((?v_0 (type_memory ?t_30_224_142 ?t_31_225_141))) (= (not_assigns (c_sort type_alloc_table ?a_223_143) (c_sort ?v_0 ?m1_222_144) (c_sort ?v_0 ?m2_221_145) (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (forall ((?p_219_147 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_31_225_141) ?p_219_147))) (=> (valid (c_sort type_alloc_table ?a_223_143) ?v_1) (=> (not_in_pset ?v_1 (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (= (acc (c_sort ?v_0 ?m2_221_145) ?v_1) (acc (c_sort ?v_0 ?m1_222_144) ?v_1))))))))))))))) +(assert (forall ((?t_32_227_148 c_type)) (forall ((?p_226_149 c_unique)) (not_in_pset (c_sort (type_pointer ?t_32_227_148) ?p_226_149) (c_sort (type_pset ?t_32_227_148) pset_empty))))) +(assert (forall ((?t_33_230_150 c_type)) (forall ((?p1_229_151 c_unique)) (forall ((?p2_228_152 c_unique)) (let ((?v_0 (type_pointer ?t_33_230_150))) (=> (not (= ?p1_229_151 ?p2_228_152)) (not_in_pset (c_sort ?v_0 ?p1_229_151) (c_sort (type_pset ?t_33_230_150) (pset_singleton (c_sort ?v_0 ?p2_228_152)))))))))) +(assert (forall ((?t_34_233_153 c_type)) (forall ((?p1_232_154 c_unique)) (forall ((?p2_231_155 c_unique)) (let ((?v_0 (type_pointer ?t_34_233_153))) (=> (not_in_pset (c_sort ?v_0 ?p1_232_154) (c_sort (type_pset ?t_34_233_153) (pset_singleton (c_sort ?v_0 ?p2_231_155)))) (not (= ?p1_232_154 ?p2_231_155)))))))) +(assert (forall ((?t_35_235_156 c_type)) (forall ((?p_234_157 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_35_235_156) ?p_234_157))) (not (not_in_pset ?v_0 (c_sort (type_pset ?t_35_235_156) (pset_singleton ?v_0)))))))) +(assert (forall ((?t_36_239_158 c_type)) (forall ((?l1_238_159 c_unique)) (forall ((?l2_237_160 c_unique)) (forall ((?p_236_161 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_36_239_158) ?p_236_161)) (?v_1 (type_pset ?t_36_239_158))) (let ((?v_2 (c_sort ?v_1 ?l1_238_159)) (?v_3 (c_sort ?v_1 ?l2_237_160))) (=> (and (not_in_pset ?v_0 ?v_2) (not_in_pset ?v_0 ?v_3)) (not_in_pset ?v_0 (c_sort ?v_1 (pset_union ?v_2 ?v_3))))))))))) +(assert (forall ((?t_37_243_162 c_type)) (forall ((?l1_242_163 c_unique)) (forall ((?l2_241_164 c_unique)) (forall ((?p_240_165 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_37_243_162) ?p_240_165)) (?v_0 (type_pset ?t_37_243_162))) (let ((?v_2 (c_sort ?v_0 ?l1_242_163))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union ?v_2 (c_sort ?v_0 ?l2_241_164)))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_38_247_166 c_type)) (forall ((?l1_246_167 c_unique)) (forall ((?l2_245_168 c_unique)) (forall ((?p_244_169 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_38_247_166) ?p_244_169)) (?v_0 (type_pset ?t_38_247_166))) (let ((?v_2 (c_sort ?v_0 ?l2_245_168))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union (c_sort ?v_0 ?l1_246_167) ?v_2))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_40_253_170 c_type)) (forall ((?t_39_252_171 c_type)) (forall ((?l_251_172 c_unique)) (forall ((?m_250_173 c_unique)) (forall ((?p_249_174 c_unique)) (let ((?v_0 (type_pointer ?t_40_253_170))) (=> (forall ((?p1_248_175 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_39_252_171) ?p1_248_175))) (=> (= ?p_249_174 (acc (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_39_252_171) ?l_251_172))))) (not_in_pset (c_sort ?v_0 ?p_249_174) (c_sort (type_pset ?t_40_253_170) (pset_star (c_sort (type_pset ?t_39_252_171) ?l_251_172) (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173)))))))))))) +(assert (forall ((?t_42_259_176 c_type)) (forall ((?t_41_258_177 c_type)) (forall ((?l_257_178 c_unique)) (forall ((?m_256_179 c_unique)) (forall ((?p_255_180 c_unique)) (let ((?v_0 (type_pointer ?t_42_259_176))) (=> (not_in_pset (c_sort ?v_0 ?p_255_180) (c_sort (type_pset ?t_42_259_176) (pset_star (c_sort (type_pset ?t_41_258_177) ?l_257_178) (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179)))) (forall ((?p1_254_181 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_41_258_177) ?p1_254_181))) (=> (= ?p_255_180 (acc (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_41_258_177) ?l_257_178))))))))))))) +(assert (forall ((?t_43_263_182 c_type)) (forall ((?p_262_183 c_unique)) (forall ((?l_261_184 c_unique)) (let ((?v_0 (type_pset ?t_43_263_182))) (=> (forall ((?p1_260_185 c_unique)) (let ((?v_1 (type_pointer ?t_43_263_182))) (let ((?v_2 (c_sort ?v_1 ?p1_260_185))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_261_184))) (not (= (base_addr (c_sort ?v_1 ?p_262_183)) (base_addr ?v_2))))))) (not_in_pset (c_sort (type_pointer ?t_43_263_182) ?p_262_183) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_261_184)))))))))) +(assert (forall ((?t_44_267_186 c_type)) (forall ((?p_266_187 c_unique)) (forall ((?l_265_188 c_unique)) (let ((?v_0 (type_pset ?t_44_267_186))) (=> (not_in_pset (c_sort (type_pointer ?t_44_267_186) ?p_266_187) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_265_188)))) (forall ((?p1_264_189 c_unique)) (let ((?v_1 (type_pointer ?t_44_267_186))) (let ((?v_2 (c_sort ?v_1 ?p1_264_189))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_265_188))) (not (= (base_addr (c_sort ?v_1 ?p_266_187)) (base_addr ?v_2))))))))))))) +(assert (forall ((?t_45_274_190 c_type)) (forall ((?p_273_191 c_unique)) (forall ((?l_272_192 c_unique)) (forall ((?a_271_193 Int)) (forall ((?b_270_194 Int)) (let ((?v_0 (type_pset ?t_45_274_190))) (=> (forall ((?p1_269_195 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) (c_sort ?v_0 ?l_272_192)) (forall ((?i_268_196 Int)) (=> (and (<= ?a_271_193 ?i_268_196) (<= ?i_268_196 ?b_270_194)) (not (= ?p_273_191 (shift (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) ?i_268_196))))))) (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p_273_191) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_272_192) ?a_271_193 ?b_270_194))))))))))) +(assert (forall ((?t_46_281_197 c_type)) (forall ((?p_280_198 c_unique)) (forall ((?l_279_199 c_unique)) (forall ((?a_278_200 Int)) (forall ((?b_277_201 Int)) (let ((?v_0 (type_pset ?t_46_281_197))) (=> (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p_280_198) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_279_199) ?a_278_200 ?b_277_201))) (forall ((?p1_276_202 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) (c_sort ?v_0 ?l_279_199))) (forall ((?i_275_203 Int)) (=> (and (<= ?a_278_200 ?i_275_203) (<= ?i_275_203 ?b_277_201)) (not (= (shift (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) ?i_275_203) ?p_280_198)))))))))))))) +(assert (forall ((?t_47_287_204 c_type)) (forall ((?p_286_205 c_unique)) (forall ((?l_285_206 c_unique)) (forall ((?a_284_207 Int)) (let ((?v_0 (type_pset ?t_47_287_204))) (=> (forall ((?p1_283_208 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) (c_sort ?v_0 ?l_285_206)) (forall ((?i_282_209 Int)) (=> (<= ?i_282_209 ?a_284_207) (not (= ?p_286_205 (shift (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) ?i_282_209))))))) (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p_286_205) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_285_206) ?a_284_207)))))))))) +(assert (forall ((?t_48_293_210 c_type)) (forall ((?p_292_211 c_unique)) (forall ((?l_291_212 c_unique)) (forall ((?a_290_213 Int)) (let ((?v_0 (type_pset ?t_48_293_210))) (=> (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p_292_211) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_291_212) ?a_290_213))) (forall ((?p1_289_214 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) (c_sort ?v_0 ?l_291_212))) (forall ((?i_288_215 Int)) (=> (<= ?i_288_215 ?a_290_213) (not (= (shift (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) ?i_288_215) ?p_292_211))))))))))))) +(assert (forall ((?t_49_299_216 c_type)) (forall ((?p_298_217 c_unique)) (forall ((?l_297_218 c_unique)) (forall ((?a_296_219 Int)) (let ((?v_0 (type_pset ?t_49_299_216))) (=> (forall ((?p1_295_220 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) (c_sort ?v_0 ?l_297_218)) (forall ((?i_294_221 Int)) (=> (<= ?a_296_219 ?i_294_221) (not (= ?p_298_217 (shift (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) ?i_294_221))))))) (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p_298_217) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_297_218) ?a_296_219)))))))))) +(assert (forall ((?t_50_305_222 c_type)) (forall ((?p_304_223 c_unique)) (forall ((?l_303_224 c_unique)) (forall ((?a_302_225 Int)) (let ((?v_0 (type_pset ?t_50_305_222))) (=> (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p_304_223) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_303_224) ?a_302_225))) (forall ((?p1_301_226 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) (c_sort ?v_0 ?l_303_224))) (forall ((?i_300_227 Int)) (=> (<= ?a_302_225 ?i_300_227) (not (= (shift (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) ?i_300_227) ?p_304_223))))))))))))) +(assert (forall ((?t_52_312_228 c_type)) (forall ((?t_51_311_229 c_type)) (forall ((?p_310_230 c_unique)) (forall ((?l_309_231 c_unique)) (forall ((?m_308_232 c_unique)) (let ((?v_0 (type_pointer ?t_51_311_229))) (=> (forall ((?p1_307_233 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_52_312_228) ?p1_307_233) (c_sort (type_pset ?t_52_312_228) ?l_309_231))) (forall ((?i_306_234 Int)) (let ((?v_1 (type_pointer ?t_52_312_228))) (not (= ?p_310_230 (acc (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_307_233) ?i_306_234))))))))) (not_in_pset (c_sort ?v_0 ?p_310_230) (c_sort (type_pset ?t_51_311_229) (pset_acc_all (c_sort (type_pset ?t_52_312_228) ?l_309_231) (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232)))))))))))) +(assert (forall ((?t_54_319_235 c_type)) (forall ((?t_53_318_236 c_type)) (forall ((?p_317_237 c_unique)) (forall ((?l_316_238 c_unique)) (forall ((?m_315_239 c_unique)) (let ((?v_0 (type_pointer ?t_53_318_236))) (=> (not_in_pset (c_sort ?v_0 ?p_317_237) (c_sort (type_pset ?t_53_318_236) (pset_acc_all (c_sort (type_pset ?t_54_319_235) ?l_316_238) (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239)))) (forall ((?p1_314_240 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_54_319_235) ?p1_314_240) (c_sort (type_pset ?t_54_319_235) ?l_316_238))) (forall ((?i_313_241 Int)) (let ((?v_1 (type_pointer ?t_54_319_235))) (not (= (acc (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_314_240) ?i_313_241))) ?p_317_237)))))))))))))) +(assert (forall ((?t_56_328_242 c_type)) (forall ((?t_55_327_243 c_type)) (forall ((?p_326_244 c_unique)) (forall ((?l_325_245 c_unique)) (forall ((?m_324_246 c_unique)) (forall ((?a_323_247 Int)) (forall ((?b_322_248 Int)) (let ((?v_0 (type_pointer ?t_55_327_243))) (=> (forall ((?p1_321_249 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_56_328_242) ?p1_321_249) (c_sort (type_pset ?t_56_328_242) ?l_325_245))) (forall ((?i_320_250 Int)) (let ((?v_1 (type_pointer ?t_56_328_242))) (=> (and (<= ?a_323_247 ?i_320_250) (<= ?i_320_250 ?b_322_248)) (not (= ?p_326_244 (acc (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_321_249) ?i_320_250)))))))))) (not_in_pset (c_sort ?v_0 ?p_326_244) (c_sort (type_pset ?t_55_327_243) (pset_acc_range (c_sort (type_pset ?t_56_328_242) ?l_325_245) (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) ?a_323_247 ?b_322_248))))))))))))) +(assert (forall ((?t_58_337_251 c_type)) (forall ((?t_57_336_252 c_type)) (forall ((?p_335_253 c_unique)) (forall ((?l_334_254 c_unique)) (forall ((?m_333_255 c_unique)) (forall ((?a_332_256 Int)) (forall ((?b_331_257 Int)) (let ((?v_0 (type_pointer ?t_57_336_252))) (=> (not_in_pset (c_sort ?v_0 ?p_335_253) (c_sort (type_pset ?t_57_336_252) (pset_acc_range (c_sort (type_pset ?t_58_337_251) ?l_334_254) (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) ?a_332_256 ?b_331_257))) (forall ((?p1_330_258 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_58_337_251) ?p1_330_258) (c_sort (type_pset ?t_58_337_251) ?l_334_254))) (forall ((?i_329_259 Int)) (let ((?v_1 (type_pointer ?t_58_337_251))) (=> (and (<= ?a_332_256 ?i_329_259) (<= ?i_329_259 ?b_331_257)) (not (= (acc (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_330_258) ?i_329_259))) ?p_335_253))))))))))))))))) +(assert (forall ((?t_60_345_260 c_type)) (forall ((?t_59_344_261 c_type)) (forall ((?p_343_262 c_unique)) (forall ((?l_342_263 c_unique)) (forall ((?m_341_264 c_unique)) (forall ((?a_340_265 Int)) (let ((?v_0 (type_pointer ?t_59_344_261))) (=> (forall ((?p1_339_266 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_60_345_260) ?p1_339_266) (c_sort (type_pset ?t_60_345_260) ?l_342_263))) (forall ((?i_338_267 Int)) (let ((?v_1 (type_pointer ?t_60_345_260))) (=> (<= ?i_338_267 ?a_340_265) (not (= ?p_343_262 (acc (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_339_266) ?i_338_267)))))))))) (not_in_pset (c_sort ?v_0 ?p_343_262) (c_sort (type_pset ?t_59_344_261) (pset_acc_range_left (c_sort (type_pset ?t_60_345_260) ?l_342_263) (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) ?a_340_265)))))))))))) +(assert (forall ((?t_62_353_268 c_type)) (forall ((?t_61_352_269 c_type)) (forall ((?p_351_270 c_unique)) (forall ((?l_350_271 c_unique)) (forall ((?m_349_272 c_unique)) (forall ((?a_348_273 Int)) (let ((?v_0 (type_pointer ?t_61_352_269))) (=> (not_in_pset (c_sort ?v_0 ?p_351_270) (c_sort (type_pset ?t_61_352_269) (pset_acc_range_left (c_sort (type_pset ?t_62_353_268) ?l_350_271) (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) ?a_348_273))) (forall ((?p1_347_274 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_62_353_268) ?p1_347_274) (c_sort (type_pset ?t_62_353_268) ?l_350_271))) (forall ((?i_346_275 Int)) (let ((?v_1 (type_pointer ?t_62_353_268))) (=> (<= ?i_346_275 ?a_348_273) (not (= (acc (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_347_274) ?i_346_275))) ?p_351_270)))))))))))))))) +(assert (forall ((?t_64_361_276 c_type)) (forall ((?t_63_360_277 c_type)) (forall ((?p_359_278 c_unique)) (forall ((?l_358_279 c_unique)) (forall ((?m_357_280 c_unique)) (forall ((?a_356_281 Int)) (let ((?v_0 (type_pointer ?t_63_360_277))) (=> (forall ((?p1_355_282 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_64_361_276) ?p1_355_282) (c_sort (type_pset ?t_64_361_276) ?l_358_279))) (forall ((?i_354_283 Int)) (let ((?v_1 (type_pointer ?t_64_361_276))) (=> (<= ?a_356_281 ?i_354_283) (not (= ?p_359_278 (acc (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_355_282) ?i_354_283)))))))))) (not_in_pset (c_sort ?v_0 ?p_359_278) (c_sort (type_pset ?t_63_360_277) (pset_acc_range_right (c_sort (type_pset ?t_64_361_276) ?l_358_279) (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) ?a_356_281)))))))))))) +(assert (forall ((?t_66_369_284 c_type)) (forall ((?t_65_368_285 c_type)) (forall ((?p_367_286 c_unique)) (forall ((?l_366_287 c_unique)) (forall ((?m_365_288 c_unique)) (forall ((?a_364_289 Int)) (let ((?v_0 (type_pointer ?t_65_368_285))) (=> (not_in_pset (c_sort ?v_0 ?p_367_286) (c_sort (type_pset ?t_65_368_285) (pset_acc_range_right (c_sort (type_pset ?t_66_369_284) ?l_366_287) (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) ?a_364_289))) (forall ((?p1_363_290 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_66_369_284) ?p1_363_290) (c_sort (type_pset ?t_66_369_284) ?l_366_287))) (forall ((?i_362_291 Int)) (let ((?v_1 (type_pointer ?t_66_369_284))) (=> (<= ?a_364_289 ?i_362_291) (not (= (acc (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_363_290) ?i_362_291))) ?p_367_286)))))))))))))))) +(assert (forall ((?t_68_376_292 c_type)) (forall ((?t_67_375_293 c_type)) (forall ((?a_374_294 c_unique)) (forall ((?l_373_295 c_unique)) (forall ((?m1_372_296 c_unique)) (forall ((?m2_371_297 c_unique)) (forall ((?m3_370_298 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a_374_294)) (?v_0 (type_memory ?t_68_376_292 ?t_67_375_293))) (let ((?v_4 (c_sort ?v_0 ?m1_372_296)) (?v_2 (c_sort ?v_0 ?m2_371_297)) (?v_3 (c_sort (type_pset ?t_67_375_293) ?l_373_295)) (?v_5 (c_sort ?v_0 ?m3_370_298))) (=> (not_assigns ?v_1 ?v_4 ?v_2 ?v_3) (=> (not_assigns ?v_1 ?v_2 ?v_5 ?v_3) (not_assigns ?v_1 ?v_4 ?v_5 ?v_3))))))))))))) +(assert (forall ((?t_70_381_299 c_type)) (forall ((?t_69_380_300 c_type)) (forall ((?a_379_301 c_unique)) (forall ((?l_378_302 c_unique)) (forall ((?m_377_303 c_unique)) (let ((?v_0 (c_sort (type_memory ?t_70_381_299 ?t_69_380_300) ?m_377_303))) (not_assigns (c_sort type_alloc_table ?a_379_301) ?v_0 ?v_0 (c_sort (type_pset ?t_69_380_300) ?l_378_302))))))))) +(declare-fun valid_acc (c_ssorted) Bool) +(assert (forall ((?t_72_386_304 c_type)) (forall ((?t_71_385_305 c_type)) (forall ((?m1_384_306 c_unique)) (= (valid_acc (c_sort (type_memory (type_pointer ?t_71_385_305) ?t_72_386_304) ?m1_384_306)) (forall ((?p_383_307 c_unique)) (forall ((?a_382_308 c_unique)) (let ((?v_1 (type_pointer ?t_71_385_305)) (?v_0 (c_sort type_alloc_table ?a_382_308)) (?v_2 (c_sort (type_pointer ?t_72_386_304) ?p_383_307))) (=> (valid ?v_0 ?v_2) (valid ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_72_386_304) ?m1_384_306) ?v_2)))))))))))) +(declare-fun valid_acc_range (c_ssorted Int) Bool) +(assert (forall ((?t_74_392_309 c_type)) (forall ((?t_73_391_310 c_type)) (forall ((?m1_390_311 c_unique)) (forall ((?size_389_312 Int)) (= (valid_acc_range (c_sort (type_memory (type_pointer ?t_73_391_310) ?t_74_392_309) ?m1_390_311) ?size_389_312) (forall ((?p_388_313 c_unique)) (forall ((?a_387_314 c_unique)) (let ((?v_1 (type_pointer ?t_73_391_310)) (?v_0 (c_sort type_alloc_table ?a_387_314)) (?v_2 (c_sort (type_pointer ?t_74_392_309) ?p_388_313))) (=> (valid ?v_0 ?v_2) (valid_range ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_74_392_309) ?m1_390_311) ?v_2)) 0 (- ?size_389_312 1)))))))))))) +(assert (forall ((?t_76_398_315 c_type)) (forall ((?t_75_397_316 c_type)) (forall ((?m1_396_317 c_unique)) (forall ((?size_395_318 Int)) (forall ((?p_394_319 c_unique)) (forall ((?a_393_320 c_unique)) (let ((?v_1 (type_pointer ?t_75_397_316))) (let ((?v_2 (c_sort (type_memory ?v_1 ?t_76_398_315) ?m1_396_317)) (?v_0 (c_sort type_alloc_table ?a_393_320)) (?v_3 (c_sort (type_pointer ?t_76_398_315) ?p_394_319))) (=> (valid_acc_range ?v_2 ?size_395_318) (=> (valid ?v_0 ?v_3) (valid ?v_0 (c_sort ?v_1 (acc ?v_2 ?v_3)))))))))))))) +(declare-fun separation1 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_78_404_321 c_type)) (forall ((?t_77_403_322 c_type)) (forall ((?m1_402_323 c_unique)) (forall ((?m2_401_324 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_77_403_322) ?t_78_404_321))) (= (separation1 (c_sort ?v_0 ?m1_402_323) (c_sort ?v_0 ?m2_401_324)) (forall ((?p_400_325 c_unique)) (forall ((?a_399_326 c_unique)) (let ((?v_1 (type_pointer ?t_77_403_322)) (?v_2 (c_sort (type_pointer ?t_78_404_321) ?p_400_325))) (=> (valid (c_sort type_alloc_table ?a_399_326) ?v_2) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_402_323) ?v_2))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_401_324) ?v_2)))))))))))))))) +(declare-fun separation1_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_80_412_327 c_type)) (forall ((?t_79_411_328 c_type)) (forall ((?m1_410_329 c_unique)) (forall ((?m2_409_330 c_unique)) (forall ((?size_408_331 Int)) (let ((?v_0 (type_memory (type_pointer ?t_79_411_328) ?t_80_412_327))) (= (separation1_range1 (c_sort ?v_0 ?m1_410_329) (c_sort ?v_0 ?m2_409_330) ?size_408_331) (forall ((?p_407_332 c_unique)) (forall ((?a_406_333 c_unique)) (=> (valid (c_sort type_alloc_table ?a_406_333) (c_sort (type_pointer ?t_80_412_327) ?p_407_332)) (forall ((?i_405_334 Int)) (let ((?v_1 (type_pointer ?t_79_411_328)) (?v_2 (type_pointer ?t_80_412_327))) (let ((?v_3 (c_sort ?v_2 ?p_407_332))) (=> (and (<= 0 ?i_405_334) (< ?i_405_334 ?size_408_331)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_410_329) (c_sort ?v_2 (shift ?v_3 ?i_405_334))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_409_330) ?v_3)))))))))))))))))))) +(declare-fun separation1_range (c_ssorted Int) Bool) +(assert (forall ((?t_82_420_335 c_type)) (forall ((?t_81_419_336 c_type)) (forall ((?m_418_337 c_unique)) (forall ((?size_417_338 Int)) (= (separation1_range (c_sort (type_memory (type_pointer ?t_81_419_336) ?t_82_420_335) ?m_418_337) ?size_417_338) (forall ((?p_416_339 c_unique)) (forall ((?a_415_340 c_unique)) (=> (valid (c_sort type_alloc_table ?a_415_340) (c_sort (type_pointer ?t_82_420_335) ?p_416_339)) (forall ((?i1_414_341 Int)) (forall ((?i2_413_342 Int)) (let ((?v_0 (type_pointer ?t_81_419_336))) (let ((?v_2 (c_sort (type_memory ?v_0 ?t_82_420_335) ?m_418_337)) (?v_1 (type_pointer ?t_82_420_335))) (let ((?v_3 (c_sort ?v_1 ?p_416_339))) (=> (and (<= 0 ?i1_414_341) (< ?i1_414_341 ?size_417_338)) (=> (and (<= 0 ?i2_413_342) (< ?i2_413_342 ?size_417_338)) (=> (not (= ?i1_414_341 ?i2_413_342)) (not (= (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i1_414_341))))) (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i2_413_342)))))))))))))))))))))))) +(declare-fun separation2 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_84_426_343 c_type)) (forall ((?t_83_425_344 c_type)) (forall ((?m1_424_345 c_unique)) (forall ((?m2_423_346 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_83_425_344) ?t_84_426_343))) (= (separation2 (c_sort ?v_0 ?m1_424_345) (c_sort ?v_0 ?m2_423_346)) (forall ((?p1_422_347 c_unique)) (forall ((?p2_421_348 c_unique)) (let ((?v_1 (type_pointer ?t_83_425_344)) (?v_2 (type_pointer ?t_84_426_343))) (=> (not (= ?p1_422_347 ?p2_421_348)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_424_345) (c_sort ?v_2 ?p1_422_347)))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_423_346) (c_sort ?v_2 ?p2_421_348))))))))))))))))) +(declare-fun separation2_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_86_435_349 c_type)) (forall ((?t_85_434_350 c_type)) (forall ((?m1_433_351 c_unique)) (forall ((?m2_432_352 c_unique)) (forall ((?size_431_353 Int)) (let ((?v_0 (type_memory (type_pointer ?t_85_434_350) ?t_86_435_349))) (= (separation2_range1 (c_sort ?v_0 ?m1_433_351) (c_sort ?v_0 ?m2_432_352) ?size_431_353) (forall ((?p_430_354 c_unique)) (forall ((?q_429_355 c_unique)) (forall ((?a_428_356 c_unique)) (forall ((?i_427_357 Int)) (let ((?v_1 (type_pointer ?t_85_434_350)) (?v_2 (type_pointer ?t_86_435_349))) (=> (and (<= 0 ?i_427_357) (< ?i_427_357 ?size_431_353)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_433_351) (c_sort ?v_2 (shift (c_sort ?v_2 ?p_430_354) ?i_427_357))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_432_352) (c_sort ?v_2 ?q_429_355)))))))))))))))))))) +(declare-fun on_heap (c_ssorted c_ssorted) Bool) +(declare-fun on_stack (c_ssorted c_ssorted) Bool) +(declare-fun fresh (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_87_438_358 c_type)) (forall ((?a_437_359 c_unique)) (forall ((?p_436_360 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_437_359)) (?v_1 (c_sort (type_pointer ?t_87_438_358) ?p_436_360))) (=> (fresh ?v_0 ?v_1) (not (valid ?v_0 ?v_1)))))))) +(assert (forall ((?t_88_442_361 c_type)) (forall ((?a_441_362 c_unique)) (forall ((?p_440_363 c_unique)) (=> (fresh (c_sort type_alloc_table ?a_441_362) (c_sort (type_pointer ?t_88_442_361) ?p_440_363)) (forall ((?i_439_364 Int)) (let ((?v_0 (type_pointer ?t_88_442_361))) (not (valid (c_sort type_alloc_table ?a_441_362) (c_sort ?v_0 (shift (c_sort ?v_0 ?p_440_363) ?i_439_364))))))))))) +(declare-fun alloc_extends (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_89_446_365 c_type)) (forall ((?a1_445_366 c_unique)) (forall ((?a2_444_367 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_445_366) (c_sort type_alloc_table ?a2_444_367)) (forall ((?q_443_368 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_89_446_365) ?q_443_368))) (=> (valid (c_sort type_alloc_table ?a1_445_366) ?v_0) (valid (c_sort type_alloc_table ?a2_444_367) ?v_0))))))))) +(assert (forall ((?t_90_451_369 c_type)) (forall ((?a1_450_370 c_unique)) (forall ((?a2_449_371 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_450_370) (c_sort type_alloc_table ?a2_449_371)) (forall ((?q_448_372 c_unique)) (forall ((?i_447_373 Int)) (let ((?v_0 (c_sort (type_pointer ?t_90_451_369) ?q_448_372))) (=> (valid_index (c_sort type_alloc_table ?a1_450_370) ?v_0 ?i_447_373) (valid_index (c_sort type_alloc_table ?a2_449_371) ?v_0 ?i_447_373)))))))))) +(assert (forall ((?t_91_457_374 c_type)) (forall ((?a1_456_375 c_unique)) (forall ((?a2_455_376 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_456_375) (c_sort type_alloc_table ?a2_455_376)) (forall ((?q_454_377 c_unique)) (forall ((?i_453_378 Int)) (forall ((?j_452_379 Int)) (let ((?v_0 (c_sort (type_pointer ?t_91_457_374) ?q_454_377))) (=> (valid_range (c_sort type_alloc_table ?a1_456_375) ?v_0 ?i_453_378 ?j_452_379) (valid_range (c_sort type_alloc_table ?a2_455_376) ?v_0 ?i_453_378 ?j_452_379))))))))))) +(assert (forall ((?a_458_380 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_458_380))) (alloc_extends ?v_0 ?v_0)))) +(assert (forall ((?a1_461_381 c_unique)) (forall ((?a2_460_382 c_unique)) (forall ((?a3_459_383 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a1_461_381)) (?v_0 (c_sort type_alloc_table ?a2_460_382)) (?v_2 (c_sort type_alloc_table ?a3_459_383))) (=> (alloc_extends ?v_1 ?v_0) (=> (alloc_extends ?v_0 ?v_2) (alloc_extends ?v_1 ?v_2)))))))) +(declare-fun free_stack (c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_92_466_384 c_type)) (forall ((?a1_465_385 c_unique)) (forall ((?a2_464_386 c_unique)) (forall ((?a3_463_387 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_465_385) (c_sort type_alloc_table ?a2_464_386) (c_sort type_alloc_table ?a3_463_387)) (forall ((?p_462_388 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a2_464_386)) (?v_1 (c_sort (type_pointer ?t_92_466_384) ?p_462_388))) (=> (valid ?v_0 ?v_1) (=> (on_heap ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_463_387) ?v_1))))))))))) +(assert (forall ((?t_93_471_389 c_type)) (forall ((?a1_470_390 c_unique)) (forall ((?a2_469_391 c_unique)) (forall ((?a3_468_392 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_470_390) (c_sort type_alloc_table ?a2_469_391) (c_sort type_alloc_table ?a3_468_392)) (forall ((?p_467_393 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a1_470_390)) (?v_1 (c_sort (type_pointer ?t_93_471_389) ?p_467_393))) (=> (valid ?v_0 ?v_1) (=> (on_stack ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_468_392) ?v_1))))))))))) +(declare-fun null () c_unique) +(assert (forall ((?t_94_475_394 c_type)) (forall ((?a_474_395 c_unique)) (not (valid (c_sort type_alloc_table ?a_474_395) (c_sort (type_pointer ?t_94_475_394) null)))))) +(declare-fun type_global () c_type) +(assert (not (forall ((?alloc c_unique)) (forall ((?b Int)) (forall ((?t c_unique)) (=> (and (= ?b 0) (valid_range (c_sort type_alloc_table ?alloc) (c_sort (type_pointer type_global) ?t) 0 9)) (forall ((?b0 Int)) (=> (= ?b0 (+ ?b 1)) (forall ((?result c_unique)) (let ((?v_0 (type_pointer type_global))) (let ((?v_2 (c_sort ?v_0 ?result))) (let ((?v_1 (offset ?v_2))) (=> (= ?result (shift (c_sort ?v_0 ?t) ?b)) (and (<= 0 ?v_1) (< ?v_1 (block_length (c_sort type_alloc_table ?alloc) ?v_2)))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/smtlibf957ea.smt2 b/test/regress/regress1/quantifiers/smtlibf957ea.smt2 new file mode 100644 index 000000000..aa82255ef --- /dev/null +++ b/test/regress/regress1/quantifiers/smtlibf957ea.smt2 @@ -0,0 +1,212 @@ +(set-logic AUFLIRA) +(set-info :source |http://proval.lri.fr/why-benchmarks |) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-sort Unit 0) +(declare-sort c_unique 0) +(declare-sort c_ssorted 0) +(declare-sort c_type 0) +(declare-sort c_Boolean 0) +(declare-fun whydivide (Int Int) Int) +(declare-fun % (Int Int) Int) +(declare-fun c_sort (c_type c_unique) c_ssorted) +(declare-fun c_Boolean_true () c_Boolean) +(declare-fun c_Boolean_false () c_Boolean) +(assert (forall ((?b_22_1 c_Boolean)) (or (= c_Boolean_true ?b_22_1) (= c_Boolean_false ?b_22_1)))) +(assert (not (= c_Boolean_true c_Boolean_false))) +(declare-fun int2U (Int) c_unique) +(declare-fun ss2Int (c_ssorted) Int) +(declare-fun real2U (Real) c_unique) +(declare-fun ss2Real (c_ssorted) Real) +(declare-fun bool2U (c_Boolean) c_unique) +(declare-fun ss2Bool (c_ssorted) c_Boolean) +(declare-fun c_int () c_type) +(declare-fun c_bool () c_type) +(declare-fun c_real () c_type) +(declare-fun c_unit () c_type) +(declare-fun c_ref (c_unique) c_unique) +(assert (forall ((?t_21_2 c_type)) (forall ((?x_20_3 c_unique)) (forall ((?y_19_4 c_unique)) (=> (= (c_sort ?t_21_2 ?x_20_3) (c_sort ?t_21_2 ?y_19_4)) (= ?x_20_3 ?y_19_4)))))) +(assert (forall ((?x_18_5 Int)) (= (ss2Int (c_sort c_int (int2U ?x_18_5))) ?x_18_5))) +(assert (forall ((?x_17_6 Int)) (forall ((?y_16_7 Int)) (=> (= (int2U ?x_17_6) (int2U ?y_16_7)) (= ?x_17_6 ?y_16_7))))) +(assert (forall ((?x_15_8 Real)) (forall ((?y_14_9 Real)) (=> (= (real2U ?x_15_8) (real2U ?y_14_9)) (= ?x_15_8 ?y_14_9))))) +(assert (forall ((?x_13_10 c_Boolean)) (forall ((?y_12_11 c_Boolean)) (=> (= (bool2U ?x_13_10) (bool2U ?y_12_11)) (= ?x_13_10 ?y_12_11))))) +(assert (forall ((?x_11_12 c_ssorted)) (forall ((?y_10_13 c_ssorted)) (=> (= (ss2Int ?x_11_12) (ss2Int ?y_10_13)) (= ?x_11_12 ?y_10_13))))) +(assert (forall ((?x_9_14 c_ssorted)) (forall ((?y_8_15 c_ssorted)) (=> (= (ss2Real ?x_9_14) (ss2Real ?y_8_15)) (= ?x_9_14 ?y_8_15))))) +(assert (forall ((?x_7_16 c_ssorted)) (forall ((?y_6_17 c_ssorted)) (=> (= (ss2Bool ?x_7_16) (ss2Bool ?y_6_17)) (= ?x_7_16 ?y_6_17))))) +(assert (forall ((?x_5_18 Real)) (= (ss2Real (c_sort c_real (real2U ?x_5_18))) ?x_5_18))) +(assert (forall ((?x_4_19 c_Boolean)) (= (ss2Bool (c_sort c_bool (bool2U ?x_4_19))) ?x_4_19))) +(assert (forall ((?x_3_20 c_unique)) (= (int2U (ss2Int (c_sort c_int ?x_3_20))) ?x_3_20))) +(assert (forall ((?x_2_21 c_unique)) (= (real2U (ss2Real (c_sort c_real ?x_2_21))) ?x_2_21))) +(assert (forall ((?x_1_22 c_unique)) (= (bool2U (ss2Bool (c_sort c_bool ?x_1_22))) ?x_1_22))) +(declare-fun eq_int (Int Int) Bool) +(declare-fun neq_int (Int Int) Bool) +(declare-fun lt_int_bool (Int Int) c_Boolean) +(declare-fun le_int_bool (Int Int) c_Boolean) +(declare-fun gt_int_bool (Int Int) c_Boolean) +(declare-fun ge_int_bool (Int Int) c_Boolean) +(declare-fun eq_int_bool (Int Int) c_Boolean) +(declare-fun neq_int_bool (Int Int) c_Boolean) +(assert (forall ((?x_40_23 Int)) (forall ((?y_39_24 Int)) (= (= (lt_int_bool ?x_40_23 ?y_39_24) c_Boolean_true) (< ?x_40_23 ?y_39_24))))) +(assert (forall ((?x_42_25 Int)) (forall ((?y_41_26 Int)) (= (= (le_int_bool ?x_42_25 ?y_41_26) c_Boolean_true) (<= ?x_42_25 ?y_41_26))))) +(assert (forall ((?x_44_27 Int)) (forall ((?y_43_28 Int)) (= (= (gt_int_bool ?x_44_27 ?y_43_28) c_Boolean_true) (> ?x_44_27 ?y_43_28))))) +(assert (forall ((?x_46_29 Int)) (forall ((?y_45_30 Int)) (= (= (ge_int_bool ?x_46_29 ?y_45_30) c_Boolean_true) (>= ?x_46_29 ?y_45_30))))) +(assert (forall ((?x_48_31 Int)) (forall ((?y_47_32 Int)) (= (= (eq_int_bool ?x_48_31 ?y_47_32) c_Boolean_true) (= ?x_48_31 ?y_47_32))))) +(assert (forall ((?x_50_33 Int)) (forall ((?y_49_34 Int)) (= (= (neq_int_bool ?x_50_33 ?y_49_34) c_Boolean_true) (not (= ?x_50_33 ?y_49_34)))))) +(declare-fun add_real (Real Real) Real) +(declare-fun sub_real (Real Real) Real) +(declare-fun mul_real (Real Real) Real) +(declare-fun div_real (Real Real) Real) +(declare-fun pow_real (Real Real) Real) +(declare-fun neg_real (Real) Real) +(declare-fun abs_real (Real) Real) +(declare-fun sqrt_real (Real) Real) +(declare-fun real_of_int (Int) Real) +(declare-fun int_of_real (Real) Int) +(declare-fun lt_real (Real Real) Bool) +(declare-fun le_real (Real Real) Bool) +(declare-fun gt_real (Real Real) Bool) +(declare-fun ge_real (Real Real) Bool) +(declare-fun eq_real (Real Real) Bool) +(declare-fun neq_real (Real Real) Bool) +(declare-fun eq_bool (c_Boolean c_Boolean) Bool) +(declare-fun neq_bool (c_Boolean c_Boolean) Bool) +(declare-fun eq_unit (c_ssorted c_ssorted) Bool) +(declare-fun neq_unit (c_ssorted c_ssorted) Bool) +(declare-fun smtlib__ite (c_Boolean c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_1_76_35 c_type)) (forall ((?x_75_36 c_unique)) (forall ((?y_74_37 c_unique)) (= (smtlib__ite c_Boolean_true (c_sort ?t_1_76_35 ?x_75_36) (c_sort ?t_1_76_35 ?y_74_37)) ?x_75_36))))) +(assert (forall ((?t_2_79_38 c_type)) (forall ((?x_78_39 c_unique)) (forall ((?y_77_40 c_unique)) (= (smtlib__ite c_Boolean_false (c_sort ?t_2_79_38 ?x_78_39) (c_sort ?t_2_79_38 ?y_77_40)) ?y_77_40))))) +(declare-fun bw_compl (Int) Int) +(declare-fun bw_and (Int Int) Int) +(declare-fun bw_xor (Int Int) Int) +(declare-fun bw_or (Int Int) Int) +(declare-fun lsl (Int Int) Int) +(declare-fun lsr (Int Int) Int) +(declare-fun non_int (Int) Int) +(declare-fun type_pointer (c_type) c_type) +(declare-fun type_addr (c_type) c_type) +(declare-fun type_alloc_table () c_type) +(declare-fun block_length (c_ssorted c_ssorted) Int) +(declare-fun base_addr (c_ssorted) c_unique) +(declare-fun offset (c_ssorted) Int) +(declare-fun shift (c_ssorted Int) c_unique) +(declare-fun sub_pointer (c_ssorted c_ssorted) Int) +(declare-fun lt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_3_88_41 c_type)) (forall ((?p1_87_42 c_unique)) (forall ((?p2_86_43 c_unique)) (let ((?v_0 (type_pointer ?t_3_88_41))) (let ((?v_1 (c_sort ?v_0 ?p1_87_42)) (?v_2 (c_sort ?v_0 ?p2_86_43))) (= (lt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (< (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun le_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_4_91_44 c_type)) (forall ((?p1_90_45 c_unique)) (forall ((?p2_89_46 c_unique)) (let ((?v_0 (type_pointer ?t_4_91_44))) (let ((?v_1 (c_sort ?v_0 ?p1_90_45)) (?v_2 (c_sort ?v_0 ?p2_89_46))) (= (le_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (<= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun gt_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_5_94_47 c_type)) (forall ((?p1_93_48 c_unique)) (forall ((?p2_92_49 c_unique)) (let ((?v_0 (type_pointer ?t_5_94_47))) (let ((?v_1 (c_sort ?v_0 ?p1_93_48)) (?v_2 (c_sort ?v_0 ?p2_92_49))) (= (gt_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (> (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun ge_pointer (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_6_97_50 c_type)) (forall ((?p1_96_51 c_unique)) (forall ((?p2_95_52 c_unique)) (let ((?v_0 (type_pointer ?t_6_97_50))) (let ((?v_1 (c_sort ?v_0 ?p1_96_51)) (?v_2 (c_sort ?v_0 ?p2_95_52))) (= (ge_pointer ?v_1 ?v_2) (and (= (base_addr ?v_1) (base_addr ?v_2)) (>= (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun valid (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_7_104_53 c_type)) (forall ((?a_103_54 c_unique)) (forall ((?p_102_55 c_unique)) (let ((?v_2 (c_sort type_alloc_table ?a_103_54)) (?v_0 (c_sort (type_pointer ?t_7_104_53) ?p_102_55))) (let ((?v_1 (offset ?v_0))) (= (valid ?v_2 ?v_0) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0)))))))))) +(declare-fun valid_index (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_8_108_56 c_type)) (forall ((?a_107_57 c_unique)) (forall ((?p_106_58 c_unique)) (forall ((?i_105_59 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_107_57)) (?v_0 (c_sort (type_pointer ?t_8_108_56) ?p_106_58))) (let ((?v_1 (+ (offset ?v_0) ?i_105_59))) (= (valid_index ?v_2 ?v_0 ?i_105_59) (and (<= 0 ?v_1) (< ?v_1 (block_length ?v_2 ?v_0))))))))))) +(declare-fun valid_range (c_ssorted c_ssorted Int Int) Bool) +(assert (forall ((?t_9_113_60 c_type)) (forall ((?a_112_61 c_unique)) (forall ((?p_111_62 c_unique)) (forall ((?i_110_63 Int)) (forall ((?j_109_64 Int)) (let ((?v_2 (c_sort type_alloc_table ?a_112_61)) (?v_0 (c_sort (type_pointer ?t_9_113_60) ?p_111_62))) (let ((?v_1 (offset ?v_0))) (= (valid_range ?v_2 ?v_0 ?i_110_63 ?j_109_64) (and (<= 0 (+ ?v_1 ?i_110_63)) (< (+ ?v_1 ?j_109_64) (block_length ?v_2 ?v_0)))))))))))) +(assert (forall ((?t_10_116_65 c_type)) (forall ((?p_115_66 c_unique)) (forall ((?i_114_67 Int)) (let ((?v_0 (type_pointer ?t_10_116_65))) (let ((?v_1 (c_sort ?v_0 ?p_115_66))) (= (offset (c_sort ?v_0 (shift ?v_1 ?i_114_67))) (+ (offset ?v_1) ?i_114_67)))))))) +(assert (forall ((?t_11_118_68 c_type)) (forall ((?p_117_69 c_unique)) (= (shift (c_sort (type_pointer ?t_11_118_68) ?p_117_69) 0) ?p_117_69)))) +(assert (forall ((?t_12_122_70 c_type)) (forall ((?p_121_71 c_unique)) (forall ((?i_120_72 Int)) (forall ((?j_119_73 Int)) (let ((?v_0 (type_pointer ?t_12_122_70))) (let ((?v_1 (c_sort ?v_0 ?p_121_71))) (= (shift (c_sort ?v_0 (shift ?v_1 ?i_120_72)) ?j_119_73) (shift ?v_1 (+ ?i_120_72 ?j_119_73)))))))))) +(assert (forall ((?t_13_125_74 c_type)) (forall ((?p_124_75 c_unique)) (forall ((?i_123_76 Int)) (let ((?v_0 (type_pointer ?t_13_125_74))) (let ((?v_1 (c_sort ?v_0 ?p_124_75))) (= (base_addr (c_sort ?v_0 (shift ?v_1 ?i_123_76))) (base_addr ?v_1)))))))) +(assert (forall ((?t_14_129_77 c_type)) (forall ((?a_128_78 c_unique)) (forall ((?p_127_79 c_unique)) (forall ((?i_126_80 Int)) (let ((?v_1 (c_sort type_alloc_table ?a_128_78)) (?v_0 (type_pointer ?t_14_129_77))) (let ((?v_2 (c_sort ?v_0 ?p_127_79))) (= (block_length ?v_1 (c_sort ?v_0 (shift ?v_2 ?i_126_80))) (block_length ?v_1 ?v_2))))))))) +(assert (forall ((?t_15_133_81 c_type)) (forall ((?a_132_82 c_unique)) (forall ((?p1_131_83 c_unique)) (forall ((?p2_130_84 c_unique)) (let ((?v_0 (type_pointer ?t_15_133_81))) (let ((?v_1 (c_sort ?v_0 ?p1_131_83)) (?v_3 (c_sort ?v_0 ?p2_130_84)) (?v_2 (c_sort type_alloc_table ?a_132_82))) (=> (= (base_addr ?v_1) (base_addr ?v_3)) (= (block_length ?v_2 ?v_1) (block_length ?v_2 ?v_3)))))))))) +(assert (forall ((?t_16_136_85 c_type)) (forall ((?p1_135_86 c_unique)) (forall ((?p2_134_87 c_unique)) (let ((?v_0 (type_pointer ?t_16_136_85))) (let ((?v_1 (c_sort ?v_0 ?p1_135_86)) (?v_2 (c_sort ?v_0 ?p2_134_87))) (=> (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2))) (= ?p1_135_86 ?p2_134_87)))))))) +(assert (forall ((?t_17_139_88 c_type)) (forall ((?p1_138_89 c_unique)) (forall ((?p2_137_90 c_unique)) (let ((?v_0 (type_pointer ?t_17_139_88))) (let ((?v_1 (c_sort ?v_0 ?p1_138_89)) (?v_2 (c_sort ?v_0 ?p2_137_90))) (=> (= ?p1_138_89 ?p2_137_90) (and (= (base_addr ?v_1) (base_addr ?v_2)) (= (offset ?v_1) (offset ?v_2)))))))))) +(assert (forall ((?t_18_144_91 c_type)) (forall ((?p1_143_92 c_unique)) (forall ((?p2_142_93 c_unique)) (forall ((?i_141_94 Int)) (forall ((?j_140_95 Int)) (let ((?v_0 (type_pointer ?t_18_144_91))) (let ((?v_1 (c_sort ?v_0 ?p1_143_92)) (?v_2 (c_sort ?v_0 ?p2_142_93))) (=> (not (= (base_addr ?v_1) (base_addr ?v_2))) (not (= (shift ?v_1 ?i_141_94) (shift ?v_2 ?j_140_95)))))))))))) +(assert (forall ((?t_19_149_96 c_type)) (forall ((?p1_148_97 c_unique)) (forall ((?p2_147_98 c_unique)) (forall ((?i_146_99 Int)) (forall ((?j_145_100 Int)) (let ((?v_0 (type_pointer ?t_19_149_96))) (let ((?v_1 (c_sort ?v_0 ?p1_148_97)) (?v_2 (c_sort ?v_0 ?p2_147_98))) (=> (not (= (+ (offset ?v_1) ?i_146_99) (+ (offset ?v_2) ?j_145_100))) (not (= (shift ?v_1 ?i_146_99) (shift ?v_2 ?j_145_100)))))))))))) +(assert (forall ((?t_20_154_101 c_type)) (forall ((?p1_153_102 c_unique)) (forall ((?p2_152_103 c_unique)) (forall ((?i_151_104 Int)) (forall ((?j_150_105 Int)) (let ((?v_0 (type_pointer ?t_20_154_101))) (let ((?v_1 (c_sort ?v_0 ?p1_153_102)) (?v_2 (c_sort ?v_0 ?p2_152_103))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (=> (= (+ (offset ?v_1) ?i_151_104) (+ (offset ?v_2) ?j_150_105)) (= (shift ?v_1 ?i_151_104) (shift ?v_2 ?j_150_105)))))))))))) +(assert (forall ((?t_21_158_106 c_type)) (forall ((?a_157_107 c_unique)) (forall ((?p_156_108 c_unique)) (forall ((?i_155_109 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_157_107)) (?v_1 (type_pointer ?t_21_158_106))) (let ((?v_2 (c_sort ?v_1 ?p_156_108))) (=> (valid_index ?v_0 ?v_2 ?i_155_109) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?i_155_109))))))))))) +(assert (forall ((?t_22_164_110 c_type)) (forall ((?a_163_111 c_unique)) (forall ((?p_162_112 c_unique)) (forall ((?i_161_113 Int)) (forall ((?j_160_114 Int)) (forall ((?k_159_115 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_163_111)) (?v_1 (type_pointer ?t_22_164_110))) (let ((?v_2 (c_sort ?v_1 ?p_162_112))) (=> (valid_range ?v_0 ?v_2 ?i_161_113 ?j_160_114) (=> (and (<= ?i_161_113 ?k_159_115) (<= ?k_159_115 ?j_160_114)) (valid ?v_0 (c_sort ?v_1 (shift ?v_2 ?k_159_115)))))))))))))) +(assert (forall ((?t_23_169_116 c_type)) (forall ((?a_168_117 c_unique)) (forall ((?p_167_118 c_unique)) (forall ((?i_166_119 Int)) (forall ((?j_165_120 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_168_117)) (?v_1 (c_sort (type_pointer ?t_23_169_116) ?p_167_118))) (=> (valid_range ?v_0 ?v_1 ?i_166_119 ?j_165_120) (=> (and (<= ?i_166_119 0) (<= 0 ?j_165_120)) (valid ?v_0 ?v_1)))))))))) +(assert (forall ((?t_24_175_121 c_type)) (forall ((?a_174_122 c_unique)) (forall ((?p_173_123 c_unique)) (forall ((?i_172_124 Int)) (forall ((?j_171_125 Int)) (forall ((?k_170_126 Int)) (let ((?v_0 (c_sort type_alloc_table ?a_174_122)) (?v_1 (c_sort (type_pointer ?t_24_175_121) ?p_173_123))) (=> (valid_range ?v_0 ?v_1 ?i_172_124 ?j_171_125) (=> (and (<= ?i_172_124 ?k_170_126) (<= ?k_170_126 ?j_171_125)) (valid_index ?v_0 ?v_1 ?k_170_126))))))))))) +(assert (forall ((?t_25_178_127 c_type)) (forall ((?p1_177_128 c_unique)) (forall ((?p2_176_129 c_unique)) (let ((?v_0 (type_pointer ?t_25_178_127))) (let ((?v_1 (c_sort ?v_0 ?p1_177_128)) (?v_2 (c_sort ?v_0 ?p2_176_129))) (=> (= (base_addr ?v_1) (base_addr ?v_2)) (= (sub_pointer ?v_1 ?v_2) (- (offset ?v_1) (offset ?v_2)))))))))) +(declare-fun type_memory (c_type c_type) c_type) +(declare-fun acc (c_ssorted c_ssorted) c_unique) +(declare-fun upd (c_ssorted c_ssorted c_ssorted) c_unique) +(assert (forall ((?t_27_212_130 c_type)) (forall ((?t_26_211_131 c_type)) (forall ((?m_210_132 c_unique)) (forall ((?p_209_133 c_unique)) (forall ((?a_208_134 c_unique)) (let ((?v_0 (type_memory ?t_26_211_131 ?t_27_212_130)) (?v_1 (c_sort (type_pointer ?t_27_212_130) ?p_209_133))) (= (acc (c_sort ?v_0 (upd (c_sort ?v_0 ?m_210_132) ?v_1 (c_sort ?t_26_211_131 ?a_208_134))) ?v_1) ?a_208_134)))))))) +(assert (forall ((?t_29_218_135 c_type)) (forall ((?t_28_217_136 c_type)) (forall ((?m_216_137 c_unique)) (forall ((?p1_215_138 c_unique)) (forall ((?p2_214_139 c_unique)) (forall ((?a_213_140 c_unique)) (let ((?v_0 (type_memory ?t_28_217_136 ?t_29_218_135))) (let ((?v_2 (c_sort ?v_0 ?m_216_137)) (?v_1 (type_pointer ?t_29_218_135))) (let ((?v_3 (c_sort ?v_1 ?p2_214_139))) (=> (not (= ?p1_215_138 ?p2_214_139)) (= (acc (c_sort ?v_0 (upd ?v_2 (c_sort ?v_1 ?p1_215_138) (c_sort ?t_28_217_136 ?a_213_140))) ?v_3) (acc ?v_2 ?v_3))))))))))))) +(assert (not (= c_Boolean_false c_Boolean_true))) +(declare-fun type_pset (c_type) c_type) +(declare-fun pset_empty () c_unique) +(declare-fun pset_singleton (c_ssorted) c_unique) +(declare-fun pset_star (c_ssorted c_ssorted) c_unique) +(declare-fun pset_all (c_ssorted) c_unique) +(declare-fun pset_range (c_ssorted Int Int) c_unique) +(declare-fun pset_range_left (c_ssorted Int) c_unique) +(declare-fun pset_range_right (c_ssorted Int) c_unique) +(declare-fun pset_acc_all (c_ssorted c_ssorted) c_unique) +(declare-fun pset_acc_range (c_ssorted c_ssorted Int Int) c_unique) +(declare-fun pset_acc_range_left (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_acc_range_right (c_ssorted c_ssorted Int) c_unique) +(declare-fun pset_union (c_ssorted c_ssorted) c_unique) +(declare-fun not_in_pset (c_ssorted c_ssorted) Bool) +(declare-fun not_assigns (c_ssorted c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_31_225_141 c_type)) (forall ((?t_30_224_142 c_type)) (forall ((?a_223_143 c_unique)) (forall ((?m1_222_144 c_unique)) (forall ((?m2_221_145 c_unique)) (forall ((?l_220_146 c_unique)) (let ((?v_0 (type_memory ?t_30_224_142 ?t_31_225_141))) (= (not_assigns (c_sort type_alloc_table ?a_223_143) (c_sort ?v_0 ?m1_222_144) (c_sort ?v_0 ?m2_221_145) (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (forall ((?p_219_147 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_31_225_141) ?p_219_147))) (=> (valid (c_sort type_alloc_table ?a_223_143) ?v_1) (=> (not_in_pset ?v_1 (c_sort (type_pset ?t_31_225_141) ?l_220_146)) (= (acc (c_sort ?v_0 ?m2_221_145) ?v_1) (acc (c_sort ?v_0 ?m1_222_144) ?v_1))))))))))))))) +(assert (forall ((?t_32_227_148 c_type)) (forall ((?p_226_149 c_unique)) (not_in_pset (c_sort (type_pointer ?t_32_227_148) ?p_226_149) (c_sort (type_pset ?t_32_227_148) pset_empty))))) +(assert (forall ((?t_33_230_150 c_type)) (forall ((?p1_229_151 c_unique)) (forall ((?p2_228_152 c_unique)) (let ((?v_0 (type_pointer ?t_33_230_150))) (=> (not (= ?p1_229_151 ?p2_228_152)) (not_in_pset (c_sort ?v_0 ?p1_229_151) (c_sort (type_pset ?t_33_230_150) (pset_singleton (c_sort ?v_0 ?p2_228_152)))))))))) +(assert (forall ((?t_34_233_153 c_type)) (forall ((?p1_232_154 c_unique)) (forall ((?p2_231_155 c_unique)) (let ((?v_0 (type_pointer ?t_34_233_153))) (=> (not_in_pset (c_sort ?v_0 ?p1_232_154) (c_sort (type_pset ?t_34_233_153) (pset_singleton (c_sort ?v_0 ?p2_231_155)))) (not (= ?p1_232_154 ?p2_231_155)))))))) +(assert (forall ((?t_35_235_156 c_type)) (forall ((?p_234_157 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_35_235_156) ?p_234_157))) (not (not_in_pset ?v_0 (c_sort (type_pset ?t_35_235_156) (pset_singleton ?v_0)))))))) +(assert (forall ((?t_36_239_158 c_type)) (forall ((?l1_238_159 c_unique)) (forall ((?l2_237_160 c_unique)) (forall ((?p_236_161 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_36_239_158) ?p_236_161)) (?v_1 (type_pset ?t_36_239_158))) (let ((?v_2 (c_sort ?v_1 ?l1_238_159)) (?v_3 (c_sort ?v_1 ?l2_237_160))) (=> (and (not_in_pset ?v_0 ?v_2) (not_in_pset ?v_0 ?v_3)) (not_in_pset ?v_0 (c_sort ?v_1 (pset_union ?v_2 ?v_3))))))))))) +(assert (forall ((?t_37_243_162 c_type)) (forall ((?l1_242_163 c_unique)) (forall ((?l2_241_164 c_unique)) (forall ((?p_240_165 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_37_243_162) ?p_240_165)) (?v_0 (type_pset ?t_37_243_162))) (let ((?v_2 (c_sort ?v_0 ?l1_242_163))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union ?v_2 (c_sort ?v_0 ?l2_241_164)))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_38_247_166 c_type)) (forall ((?l1_246_167 c_unique)) (forall ((?l2_245_168 c_unique)) (forall ((?p_244_169 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_38_247_166) ?p_244_169)) (?v_0 (type_pset ?t_38_247_166))) (let ((?v_2 (c_sort ?v_0 ?l2_245_168))) (=> (not_in_pset ?v_1 (c_sort ?v_0 (pset_union (c_sort ?v_0 ?l1_246_167) ?v_2))) (not_in_pset ?v_1 ?v_2))))))))) +(assert (forall ((?t_40_253_170 c_type)) (forall ((?t_39_252_171 c_type)) (forall ((?l_251_172 c_unique)) (forall ((?m_250_173 c_unique)) (forall ((?p_249_174 c_unique)) (let ((?v_0 (type_pointer ?t_40_253_170))) (=> (forall ((?p1_248_175 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_39_252_171) ?p1_248_175))) (=> (= ?p_249_174 (acc (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_39_252_171) ?l_251_172))))) (not_in_pset (c_sort ?v_0 ?p_249_174) (c_sort (type_pset ?t_40_253_170) (pset_star (c_sort (type_pset ?t_39_252_171) ?l_251_172) (c_sort (type_memory ?v_0 ?t_39_252_171) ?m_250_173)))))))))))) +(assert (forall ((?t_42_259_176 c_type)) (forall ((?t_41_258_177 c_type)) (forall ((?l_257_178 c_unique)) (forall ((?m_256_179 c_unique)) (forall ((?p_255_180 c_unique)) (let ((?v_0 (type_pointer ?t_42_259_176))) (=> (not_in_pset (c_sort ?v_0 ?p_255_180) (c_sort (type_pset ?t_42_259_176) (pset_star (c_sort (type_pset ?t_41_258_177) ?l_257_178) (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179)))) (forall ((?p1_254_181 c_unique)) (let ((?v_1 (c_sort (type_pointer ?t_41_258_177) ?p1_254_181))) (=> (= ?p_255_180 (acc (c_sort (type_memory ?v_0 ?t_41_258_177) ?m_256_179) ?v_1)) (not_in_pset ?v_1 (c_sort (type_pset ?t_41_258_177) ?l_257_178))))))))))))) +(assert (forall ((?t_43_263_182 c_type)) (forall ((?p_262_183 c_unique)) (forall ((?l_261_184 c_unique)) (let ((?v_0 (type_pset ?t_43_263_182))) (=> (forall ((?p1_260_185 c_unique)) (let ((?v_1 (type_pointer ?t_43_263_182))) (let ((?v_2 (c_sort ?v_1 ?p1_260_185))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_261_184))) (not (= (base_addr (c_sort ?v_1 ?p_262_183)) (base_addr ?v_2))))))) (not_in_pset (c_sort (type_pointer ?t_43_263_182) ?p_262_183) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_261_184)))))))))) +(assert (forall ((?t_44_267_186 c_type)) (forall ((?p_266_187 c_unique)) (forall ((?l_265_188 c_unique)) (let ((?v_0 (type_pset ?t_44_267_186))) (=> (not_in_pset (c_sort (type_pointer ?t_44_267_186) ?p_266_187) (c_sort ?v_0 (pset_all (c_sort ?v_0 ?l_265_188)))) (forall ((?p1_264_189 c_unique)) (let ((?v_1 (type_pointer ?t_44_267_186))) (let ((?v_2 (c_sort ?v_1 ?p1_264_189))) (=> (not (not_in_pset ?v_2 (c_sort ?v_0 ?l_265_188))) (not (= (base_addr (c_sort ?v_1 ?p_266_187)) (base_addr ?v_2))))))))))))) +(assert (forall ((?t_45_274_190 c_type)) (forall ((?p_273_191 c_unique)) (forall ((?l_272_192 c_unique)) (forall ((?a_271_193 Int)) (forall ((?b_270_194 Int)) (let ((?v_0 (type_pset ?t_45_274_190))) (=> (forall ((?p1_269_195 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) (c_sort ?v_0 ?l_272_192)) (forall ((?i_268_196 Int)) (=> (and (<= ?a_271_193 ?i_268_196) (<= ?i_268_196 ?b_270_194)) (not (= ?p_273_191 (shift (c_sort (type_pointer ?t_45_274_190) ?p1_269_195) ?i_268_196))))))) (not_in_pset (c_sort (type_pointer ?t_45_274_190) ?p_273_191) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_272_192) ?a_271_193 ?b_270_194))))))))))) +(assert (forall ((?t_46_281_197 c_type)) (forall ((?p_280_198 c_unique)) (forall ((?l_279_199 c_unique)) (forall ((?a_278_200 Int)) (forall ((?b_277_201 Int)) (let ((?v_0 (type_pset ?t_46_281_197))) (=> (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p_280_198) (c_sort ?v_0 (pset_range (c_sort ?v_0 ?l_279_199) ?a_278_200 ?b_277_201))) (forall ((?p1_276_202 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) (c_sort ?v_0 ?l_279_199))) (forall ((?i_275_203 Int)) (=> (and (<= ?a_278_200 ?i_275_203) (<= ?i_275_203 ?b_277_201)) (not (= (shift (c_sort (type_pointer ?t_46_281_197) ?p1_276_202) ?i_275_203) ?p_280_198)))))))))))))) +(assert (forall ((?t_47_287_204 c_type)) (forall ((?p_286_205 c_unique)) (forall ((?l_285_206 c_unique)) (forall ((?a_284_207 Int)) (let ((?v_0 (type_pset ?t_47_287_204))) (=> (forall ((?p1_283_208 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) (c_sort ?v_0 ?l_285_206)) (forall ((?i_282_209 Int)) (=> (<= ?i_282_209 ?a_284_207) (not (= ?p_286_205 (shift (c_sort (type_pointer ?t_47_287_204) ?p1_283_208) ?i_282_209))))))) (not_in_pset (c_sort (type_pointer ?t_47_287_204) ?p_286_205) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_285_206) ?a_284_207)))))))))) +(assert (forall ((?t_48_293_210 c_type)) (forall ((?p_292_211 c_unique)) (forall ((?l_291_212 c_unique)) (forall ((?a_290_213 Int)) (let ((?v_0 (type_pset ?t_48_293_210))) (=> (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p_292_211) (c_sort ?v_0 (pset_range_left (c_sort ?v_0 ?l_291_212) ?a_290_213))) (forall ((?p1_289_214 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) (c_sort ?v_0 ?l_291_212))) (forall ((?i_288_215 Int)) (=> (<= ?i_288_215 ?a_290_213) (not (= (shift (c_sort (type_pointer ?t_48_293_210) ?p1_289_214) ?i_288_215) ?p_292_211))))))))))))) +(assert (forall ((?t_49_299_216 c_type)) (forall ((?p_298_217 c_unique)) (forall ((?l_297_218 c_unique)) (forall ((?a_296_219 Int)) (let ((?v_0 (type_pset ?t_49_299_216))) (=> (forall ((?p1_295_220 c_unique)) (or (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) (c_sort ?v_0 ?l_297_218)) (forall ((?i_294_221 Int)) (=> (<= ?a_296_219 ?i_294_221) (not (= ?p_298_217 (shift (c_sort (type_pointer ?t_49_299_216) ?p1_295_220) ?i_294_221))))))) (not_in_pset (c_sort (type_pointer ?t_49_299_216) ?p_298_217) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_297_218) ?a_296_219)))))))))) +(assert (forall ((?t_50_305_222 c_type)) (forall ((?p_304_223 c_unique)) (forall ((?l_303_224 c_unique)) (forall ((?a_302_225 Int)) (let ((?v_0 (type_pset ?t_50_305_222))) (=> (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p_304_223) (c_sort ?v_0 (pset_range_right (c_sort ?v_0 ?l_303_224) ?a_302_225))) (forall ((?p1_301_226 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) (c_sort ?v_0 ?l_303_224))) (forall ((?i_300_227 Int)) (=> (<= ?a_302_225 ?i_300_227) (not (= (shift (c_sort (type_pointer ?t_50_305_222) ?p1_301_226) ?i_300_227) ?p_304_223))))))))))))) +(assert (forall ((?t_52_312_228 c_type)) (forall ((?t_51_311_229 c_type)) (forall ((?p_310_230 c_unique)) (forall ((?l_309_231 c_unique)) (forall ((?m_308_232 c_unique)) (let ((?v_0 (type_pointer ?t_51_311_229))) (=> (forall ((?p1_307_233 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_52_312_228) ?p1_307_233) (c_sort (type_pset ?t_52_312_228) ?l_309_231))) (forall ((?i_306_234 Int)) (let ((?v_1 (type_pointer ?t_52_312_228))) (not (= ?p_310_230 (acc (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_307_233) ?i_306_234))))))))) (not_in_pset (c_sort ?v_0 ?p_310_230) (c_sort (type_pset ?t_51_311_229) (pset_acc_all (c_sort (type_pset ?t_52_312_228) ?l_309_231) (c_sort (type_memory ?v_0 ?t_52_312_228) ?m_308_232)))))))))))) +(assert (forall ((?t_54_319_235 c_type)) (forall ((?t_53_318_236 c_type)) (forall ((?p_317_237 c_unique)) (forall ((?l_316_238 c_unique)) (forall ((?m_315_239 c_unique)) (let ((?v_0 (type_pointer ?t_53_318_236))) (=> (not_in_pset (c_sort ?v_0 ?p_317_237) (c_sort (type_pset ?t_53_318_236) (pset_acc_all (c_sort (type_pset ?t_54_319_235) ?l_316_238) (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239)))) (forall ((?p1_314_240 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_54_319_235) ?p1_314_240) (c_sort (type_pset ?t_54_319_235) ?l_316_238))) (forall ((?i_313_241 Int)) (let ((?v_1 (type_pointer ?t_54_319_235))) (not (= (acc (c_sort (type_memory ?v_0 ?t_54_319_235) ?m_315_239) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_314_240) ?i_313_241))) ?p_317_237)))))))))))))) +(assert (forall ((?t_56_328_242 c_type)) (forall ((?t_55_327_243 c_type)) (forall ((?p_326_244 c_unique)) (forall ((?l_325_245 c_unique)) (forall ((?m_324_246 c_unique)) (forall ((?a_323_247 Int)) (forall ((?b_322_248 Int)) (let ((?v_0 (type_pointer ?t_55_327_243))) (=> (forall ((?p1_321_249 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_56_328_242) ?p1_321_249) (c_sort (type_pset ?t_56_328_242) ?l_325_245))) (forall ((?i_320_250 Int)) (let ((?v_1 (type_pointer ?t_56_328_242))) (=> (and (<= ?a_323_247 ?i_320_250) (<= ?i_320_250 ?b_322_248)) (not (= ?p_326_244 (acc (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_321_249) ?i_320_250)))))))))) (not_in_pset (c_sort ?v_0 ?p_326_244) (c_sort (type_pset ?t_55_327_243) (pset_acc_range (c_sort (type_pset ?t_56_328_242) ?l_325_245) (c_sort (type_memory ?v_0 ?t_56_328_242) ?m_324_246) ?a_323_247 ?b_322_248))))))))))))) +(assert (forall ((?t_58_337_251 c_type)) (forall ((?t_57_336_252 c_type)) (forall ((?p_335_253 c_unique)) (forall ((?l_334_254 c_unique)) (forall ((?m_333_255 c_unique)) (forall ((?a_332_256 Int)) (forall ((?b_331_257 Int)) (let ((?v_0 (type_pointer ?t_57_336_252))) (=> (not_in_pset (c_sort ?v_0 ?p_335_253) (c_sort (type_pset ?t_57_336_252) (pset_acc_range (c_sort (type_pset ?t_58_337_251) ?l_334_254) (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) ?a_332_256 ?b_331_257))) (forall ((?p1_330_258 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_58_337_251) ?p1_330_258) (c_sort (type_pset ?t_58_337_251) ?l_334_254))) (forall ((?i_329_259 Int)) (let ((?v_1 (type_pointer ?t_58_337_251))) (=> (and (<= ?a_332_256 ?i_329_259) (<= ?i_329_259 ?b_331_257)) (not (= (acc (c_sort (type_memory ?v_0 ?t_58_337_251) ?m_333_255) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_330_258) ?i_329_259))) ?p_335_253))))))))))))))))) +(assert (forall ((?t_60_345_260 c_type)) (forall ((?t_59_344_261 c_type)) (forall ((?p_343_262 c_unique)) (forall ((?l_342_263 c_unique)) (forall ((?m_341_264 c_unique)) (forall ((?a_340_265 Int)) (let ((?v_0 (type_pointer ?t_59_344_261))) (=> (forall ((?p1_339_266 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_60_345_260) ?p1_339_266) (c_sort (type_pset ?t_60_345_260) ?l_342_263))) (forall ((?i_338_267 Int)) (let ((?v_1 (type_pointer ?t_60_345_260))) (=> (<= ?i_338_267 ?a_340_265) (not (= ?p_343_262 (acc (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_339_266) ?i_338_267)))))))))) (not_in_pset (c_sort ?v_0 ?p_343_262) (c_sort (type_pset ?t_59_344_261) (pset_acc_range_left (c_sort (type_pset ?t_60_345_260) ?l_342_263) (c_sort (type_memory ?v_0 ?t_60_345_260) ?m_341_264) ?a_340_265)))))))))))) +(assert (forall ((?t_62_353_268 c_type)) (forall ((?t_61_352_269 c_type)) (forall ((?p_351_270 c_unique)) (forall ((?l_350_271 c_unique)) (forall ((?m_349_272 c_unique)) (forall ((?a_348_273 Int)) (let ((?v_0 (type_pointer ?t_61_352_269))) (=> (not_in_pset (c_sort ?v_0 ?p_351_270) (c_sort (type_pset ?t_61_352_269) (pset_acc_range_left (c_sort (type_pset ?t_62_353_268) ?l_350_271) (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) ?a_348_273))) (forall ((?p1_347_274 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_62_353_268) ?p1_347_274) (c_sort (type_pset ?t_62_353_268) ?l_350_271))) (forall ((?i_346_275 Int)) (let ((?v_1 (type_pointer ?t_62_353_268))) (=> (<= ?i_346_275 ?a_348_273) (not (= (acc (c_sort (type_memory ?v_0 ?t_62_353_268) ?m_349_272) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_347_274) ?i_346_275))) ?p_351_270)))))))))))))))) +(assert (forall ((?t_64_361_276 c_type)) (forall ((?t_63_360_277 c_type)) (forall ((?p_359_278 c_unique)) (forall ((?l_358_279 c_unique)) (forall ((?m_357_280 c_unique)) (forall ((?a_356_281 Int)) (let ((?v_0 (type_pointer ?t_63_360_277))) (=> (forall ((?p1_355_282 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_64_361_276) ?p1_355_282) (c_sort (type_pset ?t_64_361_276) ?l_358_279))) (forall ((?i_354_283 Int)) (let ((?v_1 (type_pointer ?t_64_361_276))) (=> (<= ?a_356_281 ?i_354_283) (not (= ?p_359_278 (acc (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_355_282) ?i_354_283)))))))))) (not_in_pset (c_sort ?v_0 ?p_359_278) (c_sort (type_pset ?t_63_360_277) (pset_acc_range_right (c_sort (type_pset ?t_64_361_276) ?l_358_279) (c_sort (type_memory ?v_0 ?t_64_361_276) ?m_357_280) ?a_356_281)))))))))))) +(assert (forall ((?t_66_369_284 c_type)) (forall ((?t_65_368_285 c_type)) (forall ((?p_367_286 c_unique)) (forall ((?l_366_287 c_unique)) (forall ((?m_365_288 c_unique)) (forall ((?a_364_289 Int)) (let ((?v_0 (type_pointer ?t_65_368_285))) (=> (not_in_pset (c_sort ?v_0 ?p_367_286) (c_sort (type_pset ?t_65_368_285) (pset_acc_range_right (c_sort (type_pset ?t_66_369_284) ?l_366_287) (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) ?a_364_289))) (forall ((?p1_363_290 c_unique)) (=> (not (not_in_pset (c_sort (type_pointer ?t_66_369_284) ?p1_363_290) (c_sort (type_pset ?t_66_369_284) ?l_366_287))) (forall ((?i_362_291 Int)) (let ((?v_1 (type_pointer ?t_66_369_284))) (=> (<= ?a_364_289 ?i_362_291) (not (= (acc (c_sort (type_memory ?v_0 ?t_66_369_284) ?m_365_288) (c_sort ?v_1 (shift (c_sort ?v_1 ?p1_363_290) ?i_362_291))) ?p_367_286)))))))))))))))) +(assert (forall ((?t_68_376_292 c_type)) (forall ((?t_67_375_293 c_type)) (forall ((?a_374_294 c_unique)) (forall ((?l_373_295 c_unique)) (forall ((?m1_372_296 c_unique)) (forall ((?m2_371_297 c_unique)) (forall ((?m3_370_298 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a_374_294)) (?v_0 (type_memory ?t_68_376_292 ?t_67_375_293))) (let ((?v_4 (c_sort ?v_0 ?m1_372_296)) (?v_2 (c_sort ?v_0 ?m2_371_297)) (?v_3 (c_sort (type_pset ?t_67_375_293) ?l_373_295)) (?v_5 (c_sort ?v_0 ?m3_370_298))) (=> (not_assigns ?v_1 ?v_4 ?v_2 ?v_3) (=> (not_assigns ?v_1 ?v_2 ?v_5 ?v_3) (not_assigns ?v_1 ?v_4 ?v_5 ?v_3))))))))))))) +(assert (forall ((?t_70_381_299 c_type)) (forall ((?t_69_380_300 c_type)) (forall ((?a_379_301 c_unique)) (forall ((?l_378_302 c_unique)) (forall ((?m_377_303 c_unique)) (let ((?v_0 (c_sort (type_memory ?t_70_381_299 ?t_69_380_300) ?m_377_303))) (not_assigns (c_sort type_alloc_table ?a_379_301) ?v_0 ?v_0 (c_sort (type_pset ?t_69_380_300) ?l_378_302))))))))) +(declare-fun valid_acc (c_ssorted) Bool) +(assert (forall ((?t_72_386_304 c_type)) (forall ((?t_71_385_305 c_type)) (forall ((?m1_384_306 c_unique)) (= (valid_acc (c_sort (type_memory (type_pointer ?t_71_385_305) ?t_72_386_304) ?m1_384_306)) (forall ((?p_383_307 c_unique)) (forall ((?a_382_308 c_unique)) (let ((?v_1 (type_pointer ?t_71_385_305)) (?v_0 (c_sort type_alloc_table ?a_382_308)) (?v_2 (c_sort (type_pointer ?t_72_386_304) ?p_383_307))) (=> (valid ?v_0 ?v_2) (valid ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_72_386_304) ?m1_384_306) ?v_2)))))))))))) +(declare-fun valid_acc_range (c_ssorted Int) Bool) +(assert (forall ((?t_74_392_309 c_type)) (forall ((?t_73_391_310 c_type)) (forall ((?m1_390_311 c_unique)) (forall ((?size_389_312 Int)) (= (valid_acc_range (c_sort (type_memory (type_pointer ?t_73_391_310) ?t_74_392_309) ?m1_390_311) ?size_389_312) (forall ((?p_388_313 c_unique)) (forall ((?a_387_314 c_unique)) (let ((?v_1 (type_pointer ?t_73_391_310)) (?v_0 (c_sort type_alloc_table ?a_387_314)) (?v_2 (c_sort (type_pointer ?t_74_392_309) ?p_388_313))) (=> (valid ?v_0 ?v_2) (valid_range ?v_0 (c_sort ?v_1 (acc (c_sort (type_memory ?v_1 ?t_74_392_309) ?m1_390_311) ?v_2)) 0 (- ?size_389_312 1)))))))))))) +(assert (forall ((?t_76_398_315 c_type)) (forall ((?t_75_397_316 c_type)) (forall ((?m1_396_317 c_unique)) (forall ((?size_395_318 Int)) (forall ((?p_394_319 c_unique)) (forall ((?a_393_320 c_unique)) (let ((?v_1 (type_pointer ?t_75_397_316))) (let ((?v_2 (c_sort (type_memory ?v_1 ?t_76_398_315) ?m1_396_317)) (?v_0 (c_sort type_alloc_table ?a_393_320)) (?v_3 (c_sort (type_pointer ?t_76_398_315) ?p_394_319))) (=> (valid_acc_range ?v_2 ?size_395_318) (=> (valid ?v_0 ?v_3) (valid ?v_0 (c_sort ?v_1 (acc ?v_2 ?v_3)))))))))))))) +(declare-fun separation1 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_78_404_321 c_type)) (forall ((?t_77_403_322 c_type)) (forall ((?m1_402_323 c_unique)) (forall ((?m2_401_324 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_77_403_322) ?t_78_404_321))) (= (separation1 (c_sort ?v_0 ?m1_402_323) (c_sort ?v_0 ?m2_401_324)) (forall ((?p_400_325 c_unique)) (forall ((?a_399_326 c_unique)) (let ((?v_1 (type_pointer ?t_77_403_322)) (?v_2 (c_sort (type_pointer ?t_78_404_321) ?p_400_325))) (=> (valid (c_sort type_alloc_table ?a_399_326) ?v_2) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_402_323) ?v_2))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_401_324) ?v_2)))))))))))))))) +(declare-fun separation1_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_80_412_327 c_type)) (forall ((?t_79_411_328 c_type)) (forall ((?m1_410_329 c_unique)) (forall ((?m2_409_330 c_unique)) (forall ((?size_408_331 Int)) (let ((?v_0 (type_memory (type_pointer ?t_79_411_328) ?t_80_412_327))) (= (separation1_range1 (c_sort ?v_0 ?m1_410_329) (c_sort ?v_0 ?m2_409_330) ?size_408_331) (forall ((?p_407_332 c_unique)) (forall ((?a_406_333 c_unique)) (=> (valid (c_sort type_alloc_table ?a_406_333) (c_sort (type_pointer ?t_80_412_327) ?p_407_332)) (forall ((?i_405_334 Int)) (let ((?v_1 (type_pointer ?t_79_411_328)) (?v_2 (type_pointer ?t_80_412_327))) (let ((?v_3 (c_sort ?v_2 ?p_407_332))) (=> (and (<= 0 ?i_405_334) (< ?i_405_334 ?size_408_331)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_410_329) (c_sort ?v_2 (shift ?v_3 ?i_405_334))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_409_330) ?v_3)))))))))))))))))))) +(declare-fun separation1_range (c_ssorted Int) Bool) +(assert (forall ((?t_82_420_335 c_type)) (forall ((?t_81_419_336 c_type)) (forall ((?m_418_337 c_unique)) (forall ((?size_417_338 Int)) (= (separation1_range (c_sort (type_memory (type_pointer ?t_81_419_336) ?t_82_420_335) ?m_418_337) ?size_417_338) (forall ((?p_416_339 c_unique)) (forall ((?a_415_340 c_unique)) (=> (valid (c_sort type_alloc_table ?a_415_340) (c_sort (type_pointer ?t_82_420_335) ?p_416_339)) (forall ((?i1_414_341 Int)) (forall ((?i2_413_342 Int)) (let ((?v_0 (type_pointer ?t_81_419_336))) (let ((?v_2 (c_sort (type_memory ?v_0 ?t_82_420_335) ?m_418_337)) (?v_1 (type_pointer ?t_82_420_335))) (let ((?v_3 (c_sort ?v_1 ?p_416_339))) (=> (and (<= 0 ?i1_414_341) (< ?i1_414_341 ?size_417_338)) (=> (and (<= 0 ?i2_413_342) (< ?i2_413_342 ?size_417_338)) (=> (not (= ?i1_414_341 ?i2_413_342)) (not (= (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i1_414_341))))) (base_addr (c_sort ?v_0 (acc ?v_2 (c_sort ?v_1 (shift ?v_3 ?i2_413_342)))))))))))))))))))))))) +(declare-fun separation2 (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_84_426_343 c_type)) (forall ((?t_83_425_344 c_type)) (forall ((?m1_424_345 c_unique)) (forall ((?m2_423_346 c_unique)) (let ((?v_0 (type_memory (type_pointer ?t_83_425_344) ?t_84_426_343))) (= (separation2 (c_sort ?v_0 ?m1_424_345) (c_sort ?v_0 ?m2_423_346)) (forall ((?p1_422_347 c_unique)) (forall ((?p2_421_348 c_unique)) (let ((?v_1 (type_pointer ?t_83_425_344)) (?v_2 (type_pointer ?t_84_426_343))) (=> (not (= ?p1_422_347 ?p2_421_348)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_424_345) (c_sort ?v_2 ?p1_422_347)))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_423_346) (c_sort ?v_2 ?p2_421_348))))))))))))))))) +(declare-fun separation2_range1 (c_ssorted c_ssorted Int) Bool) +(assert (forall ((?t_86_435_349 c_type)) (forall ((?t_85_434_350 c_type)) (forall ((?m1_433_351 c_unique)) (forall ((?m2_432_352 c_unique)) (forall ((?size_431_353 Int)) (let ((?v_0 (type_memory (type_pointer ?t_85_434_350) ?t_86_435_349))) (= (separation2_range1 (c_sort ?v_0 ?m1_433_351) (c_sort ?v_0 ?m2_432_352) ?size_431_353) (forall ((?p_430_354 c_unique)) (forall ((?q_429_355 c_unique)) (forall ((?a_428_356 c_unique)) (forall ((?i_427_357 Int)) (let ((?v_1 (type_pointer ?t_85_434_350)) (?v_2 (type_pointer ?t_86_435_349))) (=> (and (<= 0 ?i_427_357) (< ?i_427_357 ?size_431_353)) (not (= (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m1_433_351) (c_sort ?v_2 (shift (c_sort ?v_2 ?p_430_354) ?i_427_357))))) (base_addr (c_sort ?v_1 (acc (c_sort ?v_0 ?m2_432_352) (c_sort ?v_2 ?q_429_355)))))))))))))))))))) +(declare-fun on_heap (c_ssorted c_ssorted) Bool) +(declare-fun on_stack (c_ssorted c_ssorted) Bool) +(declare-fun fresh (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_87_438_358 c_type)) (forall ((?a_437_359 c_unique)) (forall ((?p_436_360 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_437_359)) (?v_1 (c_sort (type_pointer ?t_87_438_358) ?p_436_360))) (=> (fresh ?v_0 ?v_1) (not (valid ?v_0 ?v_1)))))))) +(assert (forall ((?t_88_442_361 c_type)) (forall ((?a_441_362 c_unique)) (forall ((?p_440_363 c_unique)) (=> (fresh (c_sort type_alloc_table ?a_441_362) (c_sort (type_pointer ?t_88_442_361) ?p_440_363)) (forall ((?i_439_364 Int)) (let ((?v_0 (type_pointer ?t_88_442_361))) (not (valid (c_sort type_alloc_table ?a_441_362) (c_sort ?v_0 (shift (c_sort ?v_0 ?p_440_363) ?i_439_364))))))))))) +(declare-fun alloc_extends (c_ssorted c_ssorted) Bool) +(assert (forall ((?t_89_446_365 c_type)) (forall ((?a1_445_366 c_unique)) (forall ((?a2_444_367 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_445_366) (c_sort type_alloc_table ?a2_444_367)) (forall ((?q_443_368 c_unique)) (let ((?v_0 (c_sort (type_pointer ?t_89_446_365) ?q_443_368))) (=> (valid (c_sort type_alloc_table ?a1_445_366) ?v_0) (valid (c_sort type_alloc_table ?a2_444_367) ?v_0))))))))) +(assert (forall ((?t_90_451_369 c_type)) (forall ((?a1_450_370 c_unique)) (forall ((?a2_449_371 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_450_370) (c_sort type_alloc_table ?a2_449_371)) (forall ((?q_448_372 c_unique)) (forall ((?i_447_373 Int)) (let ((?v_0 (c_sort (type_pointer ?t_90_451_369) ?q_448_372))) (=> (valid_index (c_sort type_alloc_table ?a1_450_370) ?v_0 ?i_447_373) (valid_index (c_sort type_alloc_table ?a2_449_371) ?v_0 ?i_447_373)))))))))) +(assert (forall ((?t_91_457_374 c_type)) (forall ((?a1_456_375 c_unique)) (forall ((?a2_455_376 c_unique)) (=> (alloc_extends (c_sort type_alloc_table ?a1_456_375) (c_sort type_alloc_table ?a2_455_376)) (forall ((?q_454_377 c_unique)) (forall ((?i_453_378 Int)) (forall ((?j_452_379 Int)) (let ((?v_0 (c_sort (type_pointer ?t_91_457_374) ?q_454_377))) (=> (valid_range (c_sort type_alloc_table ?a1_456_375) ?v_0 ?i_453_378 ?j_452_379) (valid_range (c_sort type_alloc_table ?a2_455_376) ?v_0 ?i_453_378 ?j_452_379))))))))))) +(assert (forall ((?a_458_380 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a_458_380))) (alloc_extends ?v_0 ?v_0)))) +(assert (forall ((?a1_461_381 c_unique)) (forall ((?a2_460_382 c_unique)) (forall ((?a3_459_383 c_unique)) (let ((?v_1 (c_sort type_alloc_table ?a1_461_381)) (?v_0 (c_sort type_alloc_table ?a2_460_382)) (?v_2 (c_sort type_alloc_table ?a3_459_383))) (=> (alloc_extends ?v_1 ?v_0) (=> (alloc_extends ?v_0 ?v_2) (alloc_extends ?v_1 ?v_2)))))))) +(declare-fun free_stack (c_ssorted c_ssorted c_ssorted) Bool) +(assert (forall ((?t_92_466_384 c_type)) (forall ((?a1_465_385 c_unique)) (forall ((?a2_464_386 c_unique)) (forall ((?a3_463_387 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_465_385) (c_sort type_alloc_table ?a2_464_386) (c_sort type_alloc_table ?a3_463_387)) (forall ((?p_462_388 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a2_464_386)) (?v_1 (c_sort (type_pointer ?t_92_466_384) ?p_462_388))) (=> (valid ?v_0 ?v_1) (=> (on_heap ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_463_387) ?v_1))))))))))) +(assert (forall ((?t_93_471_389 c_type)) (forall ((?a1_470_390 c_unique)) (forall ((?a2_469_391 c_unique)) (forall ((?a3_468_392 c_unique)) (=> (free_stack (c_sort type_alloc_table ?a1_470_390) (c_sort type_alloc_table ?a2_469_391) (c_sort type_alloc_table ?a3_468_392)) (forall ((?p_467_393 c_unique)) (let ((?v_0 (c_sort type_alloc_table ?a1_470_390)) (?v_1 (c_sort (type_pointer ?t_93_471_389) ?p_467_393))) (=> (valid ?v_0 ?v_1) (=> (on_stack ?v_0 ?v_1) (valid (c_sort type_alloc_table ?a3_468_392) ?v_1))))))))))) +(declare-fun null () c_unique) +(assert (forall ((?t_94_475_394 c_type)) (forall ((?a_474_395 c_unique)) (not (valid (c_sort type_alloc_table ?a_474_395) (c_sort (type_pointer ?t_94_475_394) null)))))) +(declare-fun type_global () c_type) +(assert (= (% 2800 14) 0)) +(assert (forall ((?c_478_396 Int)) (let ((?v_0 (* ?c_478_396 2))) (=> (> ?v_0 0) (> ?v_0 1))))) +(assert (forall ((?c_479_397 Int)) (=> (= (% ?c_479_397 14) 0) (= (% (- ?c_479_397 14) 14) 0)))) +(assert (forall ((?c_480_398 Int)) (=> (= (% ?c_480_398 14) 0) (=> (> ?c_480_398 0) (>= ?c_480_398 14))))) +(assert (= (whydivide 10000 5) 2000)) +(assert (not (forall ((?a Int)) (forall ((?alloc c_unique)) (forall ((?b Int)) (forall ((?c Int)) (forall ((?f c_unique)) (=> (and (and (and (= ?b 0) (= ?c 2800)) (= ?a 10000)) (valid_range (c_sort type_alloc_table ?alloc) (c_sort (type_pointer type_global) ?f) 0 2800)) (forall ((?b0 Int)) (forall ((?intM_global0 c_unique)) (=> (and (and (<= 0 ?b0) (<= ?b0 2800)) (forall ((?i_0_481_408 Int)) (let ((?v_0 (type_pointer type_global))) (=> (and (<= 0 ?i_0_481_408) (< ?i_0_481_408 ?b0)) (= (ss2Int (c_sort c_int (acc (c_sort (type_memory c_int type_global) ?intM_global0) (c_sort ?v_0 (shift (c_sort ?v_0 ?f) ?i_0_481_408))))) 2000))))) (=> (= (- ?b0 ?c) 0) (= (% ?c 14) 0))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/stream-x2014-09-18-unsat.smt2 b/test/regress/regress1/quantifiers/stream-x2014-09-18-unsat.smt2 new file mode 100644 index 000000000..9243654b4 --- /dev/null +++ b/test/regress/regress1/quantifiers/stream-x2014-09-18-unsat.smt2 @@ -0,0 +1,185 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-sort A$ 0) +(declare-sort B$ 0) +(declare-sort A_set$ 0) +(declare-sort B_set$ 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_stream_set$ 0) +(declare-sort B_stream_set$ 0) +(declare-sort A_a_stream_fun$ 0) +(declare-sort A_b_stream_fun$ 0) +(declare-sort A_stream_a_fun$ 0) +(declare-sort A_stream_b_fun$ 0) +(declare-sort B_a_stream_fun$ 0) +(declare-sort B_b_stream_fun$ 0) +(declare-sort B_stream_a_fun$ 0) +(declare-sort B_stream_b_fun$ 0) +(declare-sort A_stream_stream_set$ 0) +(declare-sort B_stream_stream_set$ 0) +(declare-sort A_stream_a_stream_fun$ 0) +(declare-sort B_stream_b_stream_fun$ 0) +(declare-sort A_stream_stream_a_stream_stream_fun$ 0) +(declare-sort B_stream_stream_b_stream_stream_fun$ 0) +(declare-sort A_stream_stream_stream_a_stream_stream_stream_fun$ 0) +(declare-sort B_stream_stream_stream_b_stream_stream_stream_fun$ 0) +(declare-datatypes () ((Nat$ (zero$) (suc$ (pred$ Nat$))))) +(declare-codatatypes () ((A_stream$ (sCons$ (shd$ A$) (stl$ A_stream$))) + (B_stream$ (sCons$a (shd$a B$) (stl$a B_stream$))) + (B_stream_stream$ (sCons$b (shd$b B_stream$) (stl$b B_stream_stream$))) + (B_stream_stream_stream$ (sCons$c (shd$c B_stream_stream$) (stl$c B_stream_stream_stream$))) + (A_stream_stream$ (sCons$d (shd$d A_stream$) (stl$d A_stream_stream$))) + (A_stream_stream_stream$ (sCons$e (shd$e A_stream_stream$) (stl$e A_stream_stream_stream$))))) +(declare-fun f$ () B_a_fun$) +(declare-fun x$ () B$) +(declare-fun id$ () B_b_fun$) +(declare-fun id$a () A_a_fun$) +(declare-fun id$b () B_stream_stream_b_stream_stream_fun$) +(declare-fun id$c () A_stream_stream_a_stream_stream_fun$) +(declare-fun id$d () A_stream_a_stream_fun$) +(declare-fun id$e () B_stream_b_stream_fun$) +(declare-fun id$f () B_stream_stream_stream_b_stream_stream_stream_fun$) +(declare-fun id$g () A_stream_stream_stream_a_stream_stream_stream_fun$) +(declare-fun smap$ (B_a_fun$ B_stream$) A_stream$) +(declare-fun snth$ (B_stream_stream$ Nat$) B_stream$) +(declare-fun sdrop$ (Nat$ B_stream_stream$) B_stream_stream$) +(declare-fun smap$a (B_b_fun$) B_stream_b_stream_fun$) +(declare-fun smap$b (A_a_fun$) A_stream_a_stream_fun$) +(declare-fun smap$c (B_stream_stream_b_stream_stream_fun$) B_stream_stream_stream_b_stream_stream_stream_fun$) +(declare-fun smap$d (A_stream_stream_a_stream_stream_fun$) A_stream_stream_stream_a_stream_stream_stream_fun$) +(declare-fun smap$e (A_stream_a_stream_fun$) A_stream_stream_a_stream_stream_fun$) +(declare-fun smap$f (B_stream_b_stream_fun$) B_stream_stream_b_stream_stream_fun$) +(declare-fun smap$g (B_b_stream_fun$ B_stream$) B_stream_stream$) +(declare-fun smap$h (B_a_stream_fun$ B_stream$) A_stream_stream$) +(declare-fun smap$i (A_b_stream_fun$ A_stream$) B_stream_stream$) +(declare-fun smap$j (A_a_stream_fun$ A_stream$) A_stream_stream$) +(declare-fun smap$k (A_b_fun$ A_stream$) B_stream$) +(declare-fun smap$l (B_stream_b_fun$ B_stream_stream$) B_stream$) +(declare-fun smap$m (A_stream_b_fun$ A_stream_stream$) B_stream$) +(declare-fun smap$n (B_stream_a_fun$ B_stream_stream$) A_stream$) +(declare-fun smap$o (A_stream_a_fun$ A_stream_stream$) A_stream$) +(declare-fun snth$a (B_stream$ Nat$) B$) +(declare-fun snth$b (A_stream_stream$ Nat$) A_stream$) +(declare-fun snth$c (A_stream$ Nat$) A$) +(declare-fun member$ (B_stream$ B_stream_set$) Bool) +(declare-fun sdrop$a (Nat$ B_stream$) B_stream$) +(declare-fun sdrop$b (Nat$ A_stream_stream$) A_stream_stream$) +(declare-fun sdrop$c (Nat$ A_stream$) A_stream$) +(declare-fun fun_app$ (B_b_stream_fun$ B$) B_stream$) +(declare-fun member$a (B$ B_set$) Bool) +(declare-fun member$b (A$ A_set$) Bool) +(declare-fun member$c (A_stream$ A_stream_set$) Bool) +(declare-fun member$d (B_stream_stream$ B_stream_stream_set$) Bool) +(declare-fun member$e (A_stream_stream$ A_stream_stream_set$) Bool) +(declare-fun streams$ (B_set$) B_stream_set$) +(declare-fun fun_app$a (A_a_stream_fun$ A$) A_stream$) +(declare-fun fun_app$b (B_a_fun$ B$) A$) +(declare-fun fun_app$c (B_stream_b_stream_fun$ B_stream$) B_stream$) +(declare-fun fun_app$d (B_b_fun$ B$) B$) +(declare-fun fun_app$e (A_stream_a_stream_fun$ A_stream$) A_stream$) +(declare-fun fun_app$f (A_a_fun$ A$) A$) +(declare-fun fun_app$g (B_stream_stream_stream_b_stream_stream_stream_fun$ B_stream_stream_stream$) B_stream_stream_stream$) +(declare-fun fun_app$h (A_stream_stream_stream_a_stream_stream_stream_fun$ A_stream_stream_stream$) A_stream_stream_stream$) +(declare-fun fun_app$i (A_stream_stream_a_stream_stream_fun$ A_stream_stream$) A_stream_stream$) +(declare-fun fun_app$j (B_stream_stream_b_stream_stream_fun$ B_stream_stream$) B_stream_stream$) +(declare-fun fun_app$k (B_a_stream_fun$ B$) A_stream$) +(declare-fun fun_app$l (A_b_stream_fun$ A$) B_stream$) +(declare-fun fun_app$m (A_b_fun$ A$) B$) +(declare-fun fun_app$n (B_stream_b_fun$ B_stream$) B$) +(declare-fun fun_app$o (A_stream_b_fun$ A_stream$) B$) +(declare-fun fun_app$p (B_stream_a_fun$ B_stream$) A$) +(declare-fun fun_app$q (A_stream_a_fun$ A_stream$) A$) +(declare-fun siterate$ (B_b_fun$) B_b_stream_fun$) +(declare-fun streams$a (A_set$) A_stream_set$) +(declare-fun streams$b (B_stream_set$) B_stream_stream_set$) +(declare-fun streams$c (A_stream_set$) A_stream_stream_set$) +(declare-fun siterate$a (A_a_fun$) A_a_stream_fun$) +(assert (! (not (= (smap$ f$ (fun_app$ (siterate$ id$) x$)) (fun_app$a (siterate$a id$a) (fun_app$b f$ x$)))) :named a0)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B$)) (= (fun_app$c (smap$a ?v0) (fun_app$ (siterate$ ?v0) ?v1)) (fun_app$ (siterate$ ?v0) (fun_app$d ?v0 ?v1)))) :named a1)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A$)) (= (fun_app$e (smap$b ?v0) (fun_app$a (siterate$a ?v0) ?v1)) (fun_app$a (siterate$a ?v0) (fun_app$f ?v0 ?v1)))) :named a2)) +(assert (! (forall ((?v0 B_stream_stream_stream$)) (= (fun_app$g (smap$c id$b) ?v0) ?v0)) :named a3)) +(assert (! (forall ((?v0 A_stream_stream_stream$)) (= (fun_app$h (smap$d id$c) ?v0) ?v0)) :named a4)) +(assert (! (forall ((?v0 A_stream_stream$)) (= (fun_app$i (smap$e id$d) ?v0) ?v0)) :named a5)) +(assert (! (forall ((?v0 B_stream_stream$)) (= (fun_app$j (smap$f id$e) ?v0) ?v0)) :named a6)) +(assert (! (forall ((?v0 B_stream$)) (= (fun_app$c (smap$a id$) ?v0) ?v0)) :named a7)) +(assert (! (forall ((?v0 A_stream$)) (= (fun_app$e (smap$b id$a) ?v0) ?v0)) :named a8)) +(assert (! (= (smap$c id$b) id$f) :named a9)) +(assert (! (= (smap$d id$c) id$g) :named a10)) +(assert (! (= (smap$e id$d) id$c) :named a11)) +(assert (! (= (smap$f id$e) id$b) :named a12)) +(assert (! (= (smap$a id$) id$e) :named a13)) +(assert (! (= (smap$b id$a) id$d) :named a14)) +(assert (! (forall ((?v0 B_stream_stream$)) (! (= (fun_app$j id$b ?v0) ?v0) :pattern ((fun_app$j id$b ?v0)))) :named a15)) +(assert (! (forall ((?v0 A_stream_stream$)) (! (= (fun_app$i id$c ?v0) ?v0) :pattern ((fun_app$i id$c ?v0)))) :named a16)) +(assert (! (forall ((?v0 A_stream$)) (! (= (fun_app$e id$d ?v0) ?v0) :pattern ((fun_app$e id$d ?v0)))) :named a17)) +(assert (! (forall ((?v0 B_stream$)) (! (= (fun_app$c id$e ?v0) ?v0) :pattern ((fun_app$c id$e ?v0)))) :named a18)) +(assert (! (forall ((?v0 B$)) (! (= (fun_app$d id$ ?v0) ?v0) :pattern ((fun_app$d id$ ?v0)))) :named a19)) +(assert (! (forall ((?v0 A$)) (! (= (fun_app$f id$a ?v0) ?v0) :pattern ((fun_app$f id$a ?v0)))) :named a20)) +(assert (! (forall ((?v0 B_stream_stream$)) (! (= (fun_app$j id$b ?v0) ?v0) :pattern ((fun_app$j id$b ?v0)))) :named a21)) +(assert (! (forall ((?v0 A_stream_stream$)) (! (= (fun_app$i id$c ?v0) ?v0) :pattern ((fun_app$i id$c ?v0)))) :named a22)) +(assert (! (forall ((?v0 A_stream$)) (! (= (fun_app$e id$d ?v0) ?v0) :pattern ((fun_app$e id$d ?v0)))) :named a23)) +(assert (! (forall ((?v0 B_stream$)) (! (= (fun_app$c id$e ?v0) ?v0) :pattern ((fun_app$c id$e ?v0)))) :named a24)) +(assert (! (forall ((?v0 B$)) (! (= (fun_app$d id$ ?v0) ?v0) :pattern ((fun_app$d id$ ?v0)))) :named a25)) +(assert (! (forall ((?v0 A$)) (! (= (fun_app$f id$a ?v0) ?v0) :pattern ((fun_app$f id$a ?v0)))) :named a26)) +(assert (! (forall ((?v0 B_b_stream_fun$) (?v1 B_stream$) (?v2 Nat$)) (= (snth$ (smap$g ?v0 ?v1) ?v2) (fun_app$ ?v0 (snth$a ?v1 ?v2)))) :named a27)) +(assert (! (forall ((?v0 B_a_stream_fun$) (?v1 B_stream$) (?v2 Nat$)) (= (snth$b (smap$h ?v0 ?v1) ?v2) (fun_app$k ?v0 (snth$a ?v1 ?v2)))) :named a28)) +(assert (! (forall ((?v0 A_b_stream_fun$) (?v1 A_stream$) (?v2 Nat$)) (= (snth$ (smap$i ?v0 ?v1) ?v2) (fun_app$l ?v0 (snth$c ?v1 ?v2)))) :named a29)) +(assert (! (forall ((?v0 A_a_stream_fun$) (?v1 A_stream$) (?v2 Nat$)) (= (snth$b (smap$j ?v0 ?v1) ?v2) (fun_app$a ?v0 (snth$c ?v1 ?v2)))) :named a30)) +(assert (! (forall ((?v0 A_b_fun$) (?v1 A_stream$) (?v2 Nat$)) (= (snth$a (smap$k ?v0 ?v1) ?v2) (fun_app$m ?v0 (snth$c ?v1 ?v2)))) :named a31)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A_stream$) (?v2 Nat$)) (= (snth$c (fun_app$e (smap$b ?v0) ?v1) ?v2) (fun_app$f ?v0 (snth$c ?v1 ?v2)))) :named a32)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B_stream$) (?v2 Nat$)) (= (snth$a (fun_app$c (smap$a ?v0) ?v1) ?v2) (fun_app$d ?v0 (snth$a ?v1 ?v2)))) :named a33)) +(assert (! (forall ((?v0 B_a_fun$) (?v1 B_stream$) (?v2 Nat$)) (= (snth$c (smap$ ?v0 ?v1) ?v2) (fun_app$b ?v0 (snth$a ?v1 ?v2)))) :named a34)) +(assert (! (forall ((?v0 Nat$) (?v1 B_b_stream_fun$) (?v2 B_stream$)) (= (sdrop$ ?v0 (smap$g ?v1 ?v2)) (smap$g ?v1 (sdrop$a ?v0 ?v2)))) :named a35)) +(assert (! (forall ((?v0 Nat$) (?v1 B_a_stream_fun$) (?v2 B_stream$)) (= (sdrop$b ?v0 (smap$h ?v1 ?v2)) (smap$h ?v1 (sdrop$a ?v0 ?v2)))) :named a36)) +(assert (! (forall ((?v0 Nat$) (?v1 A_b_stream_fun$) (?v2 A_stream$)) (= (sdrop$ ?v0 (smap$i ?v1 ?v2)) (smap$i ?v1 (sdrop$c ?v0 ?v2)))) :named a37)) +(assert (! (forall ((?v0 Nat$) (?v1 A_a_stream_fun$) (?v2 A_stream$)) (= (sdrop$b ?v0 (smap$j ?v1 ?v2)) (smap$j ?v1 (sdrop$c ?v0 ?v2)))) :named a38)) +(assert (! (forall ((?v0 Nat$) (?v1 A_b_fun$) (?v2 A_stream$)) (= (sdrop$a ?v0 (smap$k ?v1 ?v2)) (smap$k ?v1 (sdrop$c ?v0 ?v2)))) :named a39)) +(assert (! (forall ((?v0 Nat$) (?v1 A_a_fun$) (?v2 A_stream$)) (= (sdrop$c ?v0 (fun_app$e (smap$b ?v1) ?v2)) (fun_app$e (smap$b ?v1) (sdrop$c ?v0 ?v2)))) :named a40)) +(assert (! (forall ((?v0 Nat$) (?v1 B_b_fun$) (?v2 B_stream$)) (= (sdrop$a ?v0 (fun_app$c (smap$a ?v1) ?v2)) (fun_app$c (smap$a ?v1) (sdrop$a ?v0 ?v2)))) :named a41)) +(assert (! (forall ((?v0 Nat$) (?v1 B_a_fun$) (?v2 B_stream$)) (= (sdrop$c ?v0 (smap$ ?v1 ?v2)) (smap$ ?v1 (sdrop$a ?v0 ?v2)))) :named a42)) +(assert (! (forall ((?v0 B_b_stream_fun$) (?v1 B_stream$)) (= (shd$b (smap$g ?v0 ?v1)) (fun_app$ ?v0 (shd$a ?v1)))) :named a43)) +(assert (! (forall ((?v0 B_a_stream_fun$) (?v1 B_stream$)) (= (shd$d (smap$h ?v0 ?v1)) (fun_app$k ?v0 (shd$a ?v1)))) :named a44)) +(assert (! (forall ((?v0 A_b_stream_fun$) (?v1 A_stream$)) (= (shd$b (smap$i ?v0 ?v1)) (fun_app$l ?v0 (shd$ ?v1)))) :named a45)) +(assert (! (forall ((?v0 A_a_stream_fun$) (?v1 A_stream$)) (= (shd$d (smap$j ?v0 ?v1)) (fun_app$a ?v0 (shd$ ?v1)))) :named a46)) +(assert (! (forall ((?v0 A_b_fun$) (?v1 A_stream$)) (= (shd$a (smap$k ?v0 ?v1)) (fun_app$m ?v0 (shd$ ?v1)))) :named a47)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A_stream$)) (= (shd$ (fun_app$e (smap$b ?v0) ?v1)) (fun_app$f ?v0 (shd$ ?v1)))) :named a48)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B_stream$)) (= (shd$a (fun_app$c (smap$a ?v0) ?v1)) (fun_app$d ?v0 (shd$a ?v1)))) :named a49)) +(assert (! (forall ((?v0 B_a_fun$) (?v1 B_stream$)) (= (shd$ (smap$ ?v0 ?v1)) (fun_app$b ?v0 (shd$a ?v1)))) :named a50)) +(assert (! (forall ((?v0 B_b_stream_fun$) (?v1 B_stream$)) (= (stl$b (smap$g ?v0 ?v1)) (smap$g ?v0 (stl$a ?v1)))) :named a51)) +(assert (! (forall ((?v0 B_a_stream_fun$) (?v1 B_stream$)) (= (stl$d (smap$h ?v0 ?v1)) (smap$h ?v0 (stl$a ?v1)))) :named a52)) +(assert (! (forall ((?v0 A_b_stream_fun$) (?v1 A_stream$)) (= (stl$b (smap$i ?v0 ?v1)) (smap$i ?v0 (stl$ ?v1)))) :named a53)) +(assert (! (forall ((?v0 A_a_stream_fun$) (?v1 A_stream$)) (= (stl$d (smap$j ?v0 ?v1)) (smap$j ?v0 (stl$ ?v1)))) :named a54)) +(assert (! (forall ((?v0 A_b_fun$) (?v1 A_stream$)) (= (stl$a (smap$k ?v0 ?v1)) (smap$k ?v0 (stl$ ?v1)))) :named a55)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A_stream$)) (= (stl$ (fun_app$e (smap$b ?v0) ?v1)) (fun_app$e (smap$b ?v0) (stl$ ?v1)))) :named a56)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B_stream$)) (= (stl$a (fun_app$c (smap$a ?v0) ?v1)) (fun_app$c (smap$a ?v0) (stl$a ?v1)))) :named a57)) +(assert (! (forall ((?v0 B_a_fun$) (?v1 B_stream$)) (= (stl$ (smap$ ?v0 ?v1)) (smap$ ?v0 (stl$a ?v1)))) :named a58)) +(assert (! (forall ((?v0 B_b_stream_fun$) (?v1 B_stream$) (?v2 B_stream_stream$)) (= (= (smap$g ?v0 ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$ ?v0 (snth$a ?v1 ?v3)) (snth$ ?v2 ?v3))))) :named a59)) +(assert (! (forall ((?v0 B_a_stream_fun$) (?v1 B_stream$) (?v2 A_stream_stream$)) (= (= (smap$h ?v0 ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$k ?v0 (snth$a ?v1 ?v3)) (snth$b ?v2 ?v3))))) :named a60)) +(assert (! (forall ((?v0 A_b_stream_fun$) (?v1 A_stream$) (?v2 B_stream_stream$)) (= (= (smap$i ?v0 ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$l ?v0 (snth$c ?v1 ?v3)) (snth$ ?v2 ?v3))))) :named a61)) +(assert (! (forall ((?v0 A_a_stream_fun$) (?v1 A_stream$) (?v2 A_stream_stream$)) (= (= (smap$j ?v0 ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$a ?v0 (snth$c ?v1 ?v3)) (snth$b ?v2 ?v3))))) :named a62)) +(assert (! (forall ((?v0 A_b_fun$) (?v1 A_stream$) (?v2 B_stream$)) (= (= (smap$k ?v0 ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$m ?v0 (snth$c ?v1 ?v3)) (snth$a ?v2 ?v3))))) :named a63)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A_stream$) (?v2 A_stream$)) (= (= (fun_app$e (smap$b ?v0) ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$f ?v0 (snth$c ?v1 ?v3)) (snth$c ?v2 ?v3))))) :named a64)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B_stream$) (?v2 B_stream$)) (= (= (fun_app$c (smap$a ?v0) ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$d ?v0 (snth$a ?v1 ?v3)) (snth$a ?v2 ?v3))))) :named a65)) +(assert (! (forall ((?v0 B_a_fun$) (?v1 B_stream$) (?v2 A_stream$)) (= (= (smap$ ?v0 ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$b ?v0 (snth$a ?v1 ?v3)) (snth$c ?v2 ?v3))))) :named a66)) +(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_a_fun$) (?v3 A_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$b (fun_app$b ?v2 ?v4) ?v3)))) (member$c (smap$ ?v2 ?v0) (streams$a ?v3)))) :named a67)) +(assert (! (forall ((?v0 A_stream$) (?v1 A_set$) (?v2 A_b_fun$) (?v3 B_set$)) (=> (and (member$c ?v0 (streams$a ?v1)) (forall ((?v4 A$)) (=> (member$b ?v4 ?v1) (member$a (fun_app$m ?v2 ?v4) ?v3)))) (member$ (smap$k ?v2 ?v0) (streams$ ?v3)))) :named a68)) +(assert (! (forall ((?v0 A_stream$) (?v1 A_set$) (?v2 A_a_fun$) (?v3 A_set$)) (=> (and (member$c ?v0 (streams$a ?v1)) (forall ((?v4 A$)) (=> (member$b ?v4 ?v1) (member$b (fun_app$f ?v2 ?v4) ?v3)))) (member$c (fun_app$e (smap$b ?v2) ?v0) (streams$a ?v3)))) :named a69)) +(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_b_fun$) (?v3 B_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$a (fun_app$d ?v2 ?v4) ?v3)))) (member$ (fun_app$c (smap$a ?v2) ?v0) (streams$ ?v3)))) :named a70)) +(assert (! (forall ((?v0 B_stream_stream$) (?v1 B_stream_set$) (?v2 B_stream_b_fun$) (?v3 B_set$)) (=> (and (member$d ?v0 (streams$b ?v1)) (forall ((?v4 B_stream$)) (=> (member$ ?v4 ?v1) (member$a (fun_app$n ?v2 ?v4) ?v3)))) (member$ (smap$l ?v2 ?v0) (streams$ ?v3)))) :named a71)) +(assert (! (forall ((?v0 A_stream_stream$) (?v1 A_stream_set$) (?v2 A_stream_b_fun$) (?v3 B_set$)) (=> (and (member$e ?v0 (streams$c ?v1)) (forall ((?v4 A_stream$)) (=> (member$c ?v4 ?v1) (member$a (fun_app$o ?v2 ?v4) ?v3)))) (member$ (smap$m ?v2 ?v0) (streams$ ?v3)))) :named a72)) +(assert (! (forall ((?v0 B_stream_stream$) (?v1 B_stream_set$) (?v2 B_stream_a_fun$) (?v3 A_set$)) (=> (and (member$d ?v0 (streams$b ?v1)) (forall ((?v4 B_stream$)) (=> (member$ ?v4 ?v1) (member$b (fun_app$p ?v2 ?v4) ?v3)))) (member$c (smap$n ?v2 ?v0) (streams$a ?v3)))) :named a73)) +(assert (! (forall ((?v0 A_stream_stream$) (?v1 A_stream_set$) (?v2 A_stream_a_fun$) (?v3 A_set$)) (=> (and (member$e ?v0 (streams$c ?v1)) (forall ((?v4 A_stream$)) (=> (member$c ?v4 ?v1) (member$b (fun_app$q ?v2 ?v4) ?v3)))) (member$c (smap$o ?v2 ?v0) (streams$a ?v3)))) :named a74)) +(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_b_stream_fun$) (?v3 B_stream_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$ (fun_app$ ?v2 ?v4) ?v3)))) (member$d (smap$g ?v2 ?v0) (streams$b ?v3)))) :named a75)) +(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_a_stream_fun$) (?v3 A_stream_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$c (fun_app$k ?v2 ?v4) ?v3)))) (member$e (smap$h ?v2 ?v0) (streams$c ?v3)))) :named a76)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B$)) (= (shd$a (fun_app$ (siterate$ ?v0) ?v1)) ?v1)) :named a77)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A$)) (= (shd$ (fun_app$a (siterate$a ?v0) ?v1)) ?v1)) :named a78)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B$)) (= (stl$a (fun_app$ (siterate$ ?v0) ?v1)) (fun_app$ (siterate$ ?v0) (fun_app$d ?v0 ?v1)))) :named a79)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A$)) (= (stl$ (fun_app$a (siterate$a ?v0) ?v1)) (fun_app$a (siterate$a ?v0) (fun_app$f ?v0 ?v1)))) :named a80)) +(assert (! (forall ((?v0 B_b_fun$) (?v1 B$)) (= (fun_app$ (siterate$ ?v0) ?v1) (sCons$a ?v1 (fun_app$ (siterate$ ?v0) (fun_app$d ?v0 ?v1))))) :named a81)) +(assert (! (forall ((?v0 A_a_fun$) (?v1 A$)) (= (fun_app$a (siterate$a ?v0) ?v1) (sCons$ ?v1 (fun_app$a (siterate$a ?v0) (fun_app$f ?v0 ?v1))))) :named a82)) +(check-sat) diff --git a/test/regress/regress1/quantifiers/subtype-param-unk.smt2 b/test/regress/regress1/quantifiers/subtype-param-unk.smt2 new file mode 100644 index 000000000..f3ee6a86a --- /dev/null +++ b/test/regress/regress1/quantifiers/subtype-param-unk.smt2 @@ -0,0 +1,24 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: (error "argument type is not a subtype of the function's argument type: +; EXPECT: argument: x +; EXPECT: has type: (List Int) +; EXPECT: not subtype: (List Real) +; EXPECT: in term : (R (as x (List Real)))") +; EXIT: 1 + +; this will fail if type rule for APPLY_UF requires arguments to be subtypes +(set-logic ALL_SUPPORTED) + +(declare-datatypes (T) ((List (cons (hd T) (tl (List T))) (nil)))) + +(declare-fun R ((List Real)) Bool) +(assert (forall ((x (List Int))) (R x))) +(declare-fun j1 () (List Real)) +(assert (not (R j1))) + +(declare-fun Q ((Array Int Real)) Bool) +(assert (forall ((x (Array Int Int))) (Q x))) +(declare-fun j2 () (Array Int Real)) +(assert (not (Q j2))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/subtype-param.smt2 b/test/regress/regress1/quantifiers/subtype-param.smt2 new file mode 100644 index 000000000..860c03b6f --- /dev/null +++ b/test/regress/regress1/quantifiers/subtype-param.smt2 @@ -0,0 +1,24 @@ +; COMMAND-LINE: --lang=smt2.5 +; EXPECT: (error "argument type is not a subtype of the function's argument type: +; EXPECT: argument: x +; EXPECT: has type: (Array Int Int) +; EXPECT: not subtype: (Array Int Real) +; EXPECT: in term : (Q (as x (Array Int Real)))") +; EXIT: 1 + +(set-logic ALL_SUPPORTED) +(set-info :status unsat) + +(declare-datatypes (T) ((List (cons (hd T) (tl (List T))) (nil)))) + +(declare-fun R ((List Real)) Bool) +(assert (forall ((x (List Real))) (R x))) + +(declare-fun Q ((Array Int Real)) Bool) +(assert (forall ((x (Array Int Int))) (Q x))) + +(declare-fun k1 () (List Int)) +(declare-fun k2 () (Array Real Int)) +(assert (or (not (R k1)) (not (Q k2)))) + +(check-sat) diff --git a/test/regress/regress1/quantifiers/symmetric_unsat_7.smt2 b/test/regress/regress1/quantifiers/symmetric_unsat_7.smt2 new file mode 100644 index 000000000..6acf4a3c6 --- /dev/null +++ b/test/regress/regress1/quantifiers/symmetric_unsat_7.smt2 @@ -0,0 +1,34 @@ +(set-logic AUFLIRA) +(set-info :source | Example extracted from Peter Baumgartner's talk at CADE-21: Logical Engineering with Instance-Based Methods. + +It was translated to SMT-LIB by Leonardo de Moura |) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-fun symmetric ((Array Int (Array Int Real)) Int) Bool) +(declare-fun n () Int) +(declare-fun a0 () (Array Int (Array Int Real))) +(declare-fun e0 () Real) +(declare-fun a1 () (Array Int (Array Int Real))) +(declare-fun e1 () Real) +(declare-fun a2 () (Array Int (Array Int Real))) +(declare-fun e2 () Real) +(declare-fun a3 () (Array Int (Array Int Real))) +(declare-fun e3 () Real) +(declare-fun a4 () (Array Int (Array Int Real))) +(declare-fun e4 () Real) +(declare-fun a5 () (Array Int (Array Int Real))) +(declare-fun e5 () Real) +(declare-fun a6 () (Array Int (Array Int Real))) +(declare-fun e6 () Real) +(assert (forall ((?a (Array Int (Array Int Real))) (?n Int)) (= (symmetric ?a ?n) (forall ((?i Int) (?j Int)) (=> (and (<= 1 ?i) (<= ?i ?n) (<= 1 ?j) (<= ?j ?n)) (= (select (select ?a ?i) ?j) (select (select ?a ?j) ?i))))))) +(assert (symmetric a0 n)) +(assert (= a1 (store a0 0 (store (select a0 0) 0 e0)))) +(assert (= a2 (store a1 1 (store (select a1 1) 1 e1)))) +(assert (= a3 (store a2 2 (store (select a2 2) 2 e2)))) +(assert (= a4 (store a3 3 (store (select a3 3) 3 e3)))) +(assert (= a5 (store a4 4 (store (select a4 4) 4 e4)))) +(assert (= a6 (store a5 5 (store (select a5 5) 5 e5)))) +(assert (not (symmetric a6 n))) +(check-sat) +(exit) diff --git a/test/regress/regress1/quantifiers/z3.620661-no-fv-trigger.smt2 b/test/regress/regress1/quantifiers/z3.620661-no-fv-trigger.smt2 new file mode 100644 index 000000000..aad2a4691 --- /dev/null +++ b/test/regress/regress1/quantifiers/z3.620661-no-fv-trigger.smt2 @@ -0,0 +1,87 @@ +(set-logic AUFNIRA) +(set-info :status unsat) +(declare-sort S1 0) +(declare-sort S2 0) +(declare-sort S3 0) +(declare-sort S4 0) +(declare-sort S5 0) +(declare-sort S6 0) +(declare-sort S7 0) +(declare-sort S8 0) +(declare-sort S9 0) +(declare-sort S10 0) +(declare-sort S11 0) +(declare-sort S12 0) +(declare-sort S13 0) +(declare-fun f1 () S1) +(declare-fun f2 () S1) +(declare-fun f3 (S2 Real) Real) +(declare-fun f4 (S3 Real) S2) +(declare-fun f5 () S3) +(declare-fun f6 (S4 Int) Int) +(declare-fun f7 (S5 Int) S4) +(declare-fun f8 () S5) +(declare-fun f9 () S2) +(declare-fun f10 () Real) +(declare-fun f11 () Real) +(declare-fun f12 () S2) +(declare-fun f13 (S7 S6) Real) +(declare-fun f14 () S7) +(declare-fun f15 () S2) +(declare-fun f16 () S2) +(declare-fun f17 (S8 Int) S6) +(declare-fun f18 () S8) +(declare-fun f19 (S9 S6) Int) +(declare-fun f20 () S9) +(declare-fun f21 (S10 Real) S7) +(declare-fun f22 () S10) +(declare-fun f23 () S2) +(declare-fun f24 (S11 S6) S6) +(declare-fun f25 (S12 S6) S11) +(declare-fun f26 () S12) +(declare-fun f27 () S12) +(declare-fun f28 (S13 Int) S9) +(declare-fun f29 () S13) +(declare-fun f30 () S2) +(declare-fun f31 () S4) +(assert (not (= f1 f2))) +(assert (forall ((?v0 Real) (?v1 Real)) (= (f3 (f4 f5 ?v0) ?v1) (* ?v0 ?v1)))) +(assert (forall ((?v0 Int) (?v1 Int)) (= (f6 (f7 f8 ?v0) ?v1) (* ?v0 ?v1)))) +(assert (not (= (f3 f9 (- f10 f11)) (- (f3 f9 f10))))) +(assert (= (f3 f9 f11) 0.0)) +(assert (forall ((?v0 Real)) (= (f3 f9 (+ f11 ?v0)) (- (f3 f9 ?v0))))) +(assert (= (f3 f9 (/ f11 2.0)) 1.0)) +(assert (= (f3 f9 (/ f11 6.0)) (/ 1.0 2.0))) +(assert (= (f3 f9 (* 2.0 f11)) 0.0)) +(assert (= (f3 f9 (* (/ 3.0 2.0) f11)) (- 1.0))) +(assert (let ((?v_0 2.0)) (<= (/ f11 ?v_0) ?v_0))) +(assert (let ((?v_0 2.0)) (< (/ f11 ?v_0) ?v_0))) +(assert (< (- (* 2.0 f11)) f11)) +(assert (< (- (/ f11 2.0)) 0.0)) +(assert (<= 2.0 f11)) +(assert (<= 0.0 (/ f11 2.0))) +(assert (< 0.0 (/ f11 2.0))) +(assert (< f11 4.0)) +(assert (<= 0.0 f11)) +(assert (< 0.0 f11)) +(assert (let ((?v_0 2.0)) (not (= (/ f11 ?v_0) ?v_0)))) +(assert (not (= (/ f11 2.0) 0.0))) +(assert (not (< f11 0.0))) +(assert (not (= f11 0.0))) +(assert (forall ((?v0 S6) (?v1 S6)) (= (= (f13 f14 ?v0) (f13 f14 ?v1)) (= ?v0 ?v1)))) +(assert (forall ((?v0 S6) (?v1 S6)) (= (< (f13 f14 ?v0) (f13 f14 ?v1)) (< (f19 f20 ?v0) (f19 f20 ?v1))))) +(assert (forall ((?v0 S6) (?v1 S6)) (= (<= (f13 f14 ?v0) (f13 f14 ?v1)) (<= (f19 f20 ?v0) (f19 f20 ?v1))))) +(assert (forall ((?v0 S6) (?v1 S6)) (let ((?v_0 (f19 f20 ?v1)) (?v_1 (f19 f20 ?v0))) (=> (<= ?v_1 ?v_0) (= (f13 f14 (f17 f18 (- ?v_0 ?v_1))) (- (f13 f14 ?v1) (f13 f14 ?v0))))))) +(assert (forall ((?v0 Real) (?v1 Real)) (exists ((?v2 Real) (?v3 Real)) (and (= ?v0 (* ?v2 (f3 f15 ?v3))) (= ?v1 (* ?v2 (f3 f9 ?v3))))))) +(assert (< 1.0 (f3 f16 2.0))) +(assert (< 0.0 (f3 f16 2.0))) +(assert (<= 0.0 (f3 f16 2.0))) +(assert (forall ((?v0 Real) (?v1 Real)) (<= 0.0 (f3 f16 (+ (* ?v0 ?v0) (* ?v1 ?v1)))))) +(assert (forall ((?v0 Real) (?v1 Real)) (=> (<= ?v0 ?v1) (<= (f3 f16 ?v0) (f3 f16 ?v1))))) +(assert (forall ((?v0 Real) (?v1 Real)) (=> (< ?v0 ?v1) (< (f3 f16 ?v0) (f3 f16 ?v1))))) +(assert (forall ((?v0 Real)) (let ((?v_0 0.0)) (=> (<= ?v_0 ?v0) (=> (= (f3 f16 ?v0) ?v_0) (= ?v0 ?v_0)))))) +(assert (forall ((?v0 Real)) (=> (< 0.0 ?v0) (< (/ ?v0 (f3 f16 2.0)) ?v0)))) +(assert (forall ((?v0 Real)) (let ((?v_0 0.0)) (=> (<= ?v_0 ?v0) (<= ?v_0 (f3 f16 ?v0)))))) +(assert (forall ((?v0 Real)) (let ((?v_0 1.0)) (=> (<= ?v_0 ?v0) (<= ?v_0 (f3 f16 ?v0)))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/rels/Makefile.am b/test/regress/regress1/rels/Makefile.am new file mode 100644 index 000000000..c35ea2914 --- /dev/null +++ b/test/regress/regress1/rels/Makefile.am @@ -0,0 +1,66 @@ +# don't override a BINARY imported from a personal.mk +@mk_if@eq ($(BINARY),) +@mk_empty@BINARY = cvc4 +end@mk_if@ + +LOG_COMPILER = @srcdir@/../../run_regression +AM_LOG_FLAGS = $(RUN_REGRESSION_ARGS) @abs_top_builddir@/src/main/$(BINARY)$(EXEEXT) + +if AUTOMAKE_1_11 +# old-style (pre-automake 1.12) test harness +TESTS_ENVIRONMENT = \ + $(LOG_COMPILER) \ + $(AM_LOG_FLAGS) $(LOG_FLAGS) +endif + +# These are run for all build profiles. +# If a test shouldn't be run in e.g. competition mode, +# put it below in "TESTS +=" +TESTS = \ + bv1p.cvc \ + rel_pressure_0.cvc \ + rel_tc_5_1.cvc \ + set-strat.cvc \ + addr_book_1_1.cvc \ + addr_book_1.cvc \ + bv1-unit.cvc \ + bv1-unitb.cvc \ + bv1.cvc \ + bv1p-sat.cvc \ + bv2.cvc \ + iden_1_1.cvc \ + join-eq-structure_0_1.cvc \ + join-eq-structure-and.cvc \ + join-eq-structure.cvc \ + joinImg_0_1.cvc \ + joinImg_0_2.cvc \ + joinImg_1_1.cvc \ + joinImg_1.cvc \ + joinImg_2_1.cvc \ + joinImg_2.cvc \ + prod-mod-eq.cvc \ + prod-mod-eq2.cvc \ + rel_complex_3.cvc \ + rel_complex_4.cvc \ + rel_complex_5.cvc \ + rel_mix_0_1.cvc \ + rel_tc_10_1.cvc \ + rel_tc_4_1.cvc \ + rel_tc_4.cvc \ + rel_tc_6.cvc \ + rel_tc_9_1.cvc \ + rel_tp_2.cvc \ + rel_tp_join_2_1.cvc \ + strat_0_1.cvc \ + strat.cvc + +EXTRA_DIST = $(TESTS) \ + garbage_collect.cvc + +# synonyms for "check" in this directory +.PHONY: regress regress1 test +regress regress1 test: check + +# do nothing in this subdir +.PHONY: regress0 regress2 regress3 regress4 +regress0 regress2 regress3 regress4: diff --git a/test/regress/regress1/rels/addr_book_1.cvc b/test/regress/regress1/rels/addr_book_1.cvc new file mode 100644 index 000000000..34176f274 --- /dev/null +++ b/test/regress/regress1/rels/addr_book_1.cvc @@ -0,0 +1,45 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +Atom : TYPE; +AtomTup : TYPE = [Atom]; +AtomBinTup : TYPE = [Atom, Atom]; +AtomTerTup : TYPE = [Atom, Atom, Atom]; +Target: SET OF AtomTup; + +Name: SET OF AtomTup; +Addr: SET OF AtomTup; +Book: SET OF AtomTup; +names: SET OF AtomBinTup; +addr: SET OF AtomTerTup; + +b1: Atom; +b1_tup : AtomTup; +ASSERT b1_tup = TUPLE(b1); +ASSERT b1_tup IS_IN Book; + +b2: Atom; +b2_tup : AtomTup; +ASSERT b2_tup = TUPLE(b2); +ASSERT b2_tup IS_IN Book; + +b3: Atom; +b3_tup : AtomTup; +ASSERT b3_tup = TUPLE(b3); +ASSERT b3_tup IS_IN Book; + +m: Atom; +m_tup : AtomTup; +ASSERT m_tup = TUPLE(m); +ASSERT m_tup IS_IN Name; + +t: Atom; +t_tup : AtomTup; +ASSERT t_tup = TUPLE(t); +ASSERT t_tup IS_IN Target; + +ASSERT ({m_tup} JOIN ({b1_tup} JOIN addr)) = {}::SET OF AtomTup; +ASSERT ({b2_tup} JOIN addr) = ({b1_tup} JOIN addr) | {(m,t)}; +ASSERT ({b3_tup} JOIN addr) = ({b2_tup} JOIN addr) - {(m,t)}; +ASSERT NOT (({b1_tup} JOIN addr) = ({b3_tup} JOIN addr)); + +CHECKSAT;
\ No newline at end of file diff --git a/test/regress/regress1/rels/addr_book_1_1.cvc b/test/regress/regress1/rels/addr_book_1_1.cvc new file mode 100644 index 000000000..3273ade3a --- /dev/null +++ b/test/regress/regress1/rels/addr_book_1_1.cvc @@ -0,0 +1,45 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +Atom : TYPE; +AtomTup : TYPE = [Atom]; +AtomBinTup : TYPE = [Atom, Atom]; +AtomTerTup : TYPE = [Atom, Atom, Atom]; +Target: SET OF AtomTup; + +Name: SET OF AtomTup; +Addr: SET OF AtomTup; +Book: SET OF AtomTup; +names: SET OF AtomBinTup; +addr: SET OF AtomTerTup; + +b1: Atom; +b1_tup : AtomTup; +ASSERT b1_tup = TUPLE(b1); +ASSERT b1_tup IS_IN Book; + +b2: Atom; +b2_tup : AtomTup; +ASSERT b2_tup = TUPLE(b2); +ASSERT b2_tup IS_IN Book; + +b3: Atom; +b3_tup : AtomTup; +ASSERT b3_tup = TUPLE(b3); +ASSERT b3_tup IS_IN Book; + +m: Atom; +m_tup : AtomTup; +ASSERT m_tup = TUPLE(m); +ASSERT m_tup IS_IN Name; + +t: Atom; +t_tup : AtomTup; +ASSERT t_tup = TUPLE(t); +ASSERT t_tup IS_IN Target; + +ASSERT ({m_tup} JOIN ({b1_tup} JOIN addr)) = {}::SET OF AtomTup; +ASSERT ({b2_tup} JOIN addr) = ({b1_tup} JOIN addr) | {(m,t)}; +ASSERT ({b3_tup} JOIN addr) = ({b2_tup} JOIN addr) - {(m,t)}; +ASSERT (({b1_tup} JOIN addr) = ({b3_tup} JOIN addr)); + +CHECKSAT;
\ No newline at end of file diff --git a/test/regress/regress1/rels/bv1-unit.cvc b/test/regress/regress1/rels/bv1-unit.cvc new file mode 100644 index 000000000..970ebdc8c --- /dev/null +++ b/test/regress/regress1/rels/bv1-unit.cvc @@ -0,0 +1,21 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +DATATYPE unit = u END; +BvPair: TYPE = [BITVECTOR(1), unit, BITVECTOR(1)]; +x : SET OF BvPair; +y : SET OF BvPair; + +a : BITVECTOR(1); +b : BITVECTOR(1); +c : BITVECTOR(1); +d : BITVECTOR(1); +e : BITVECTOR(1); + +ASSERT NOT ( b = c ); + +ASSERT (a, u, b) IS_IN x; +ASSERT (a, u, c) IS_IN x; +ASSERT (d, u, a) IS_IN y; +ASSERT NOT ( ( a, u, u, a ) IS_IN (x JOIN y)); + +CHECKSAT; diff --git a/test/regress/regress1/rels/bv1-unitb.cvc b/test/regress/regress1/rels/bv1-unitb.cvc new file mode 100644 index 000000000..50a5bb48a --- /dev/null +++ b/test/regress/regress1/rels/bv1-unitb.cvc @@ -0,0 +1,22 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +DATATYPE unitb = ub(data : BITVECTOR(1)) END; +BvPair: TYPE = [BITVECTOR(1), unitb, BITVECTOR(1)]; +x : SET OF BvPair; +y : SET OF BvPair; + +a : BITVECTOR(1); +b : BITVECTOR(1); +c : BITVECTOR(1); +d : BITVECTOR(1); +e : BITVECTOR(1); +u : unitb; + +ASSERT NOT ( b = c ); + +ASSERT (a, u, b) IS_IN x; +ASSERT (a, u, c) IS_IN x; +ASSERT (d, u, a) IS_IN y; +ASSERT NOT ( ( a, u, u, a ) IS_IN (x JOIN y)); + +CHECKSAT; diff --git a/test/regress/regress1/rels/bv1.cvc b/test/regress/regress1/rels/bv1.cvc new file mode 100644 index 000000000..95e7419ba --- /dev/null +++ b/test/regress/regress1/rels/bv1.cvc @@ -0,0 +1,20 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +BvPair: TYPE = [BITVECTOR(1), BITVECTOR(1)]; +x : SET OF BvPair; +y : SET OF BvPair; + +a : BITVECTOR(1); +b : BITVECTOR(1); +c : BITVECTOR(1); +d : BITVECTOR(1); +e : BITVECTOR(1); + +ASSERT NOT ( b = c ); + +ASSERT (a, b) IS_IN x; +ASSERT (a, c) IS_IN x; +ASSERT (d, a) IS_IN y; +ASSERT NOT ( ( a, a ) IS_IN (x JOIN y)); + +CHECKSAT; diff --git a/test/regress/regress1/rels/bv1p-sat.cvc b/test/regress/regress1/rels/bv1p-sat.cvc new file mode 100644 index 000000000..5eceb214c --- /dev/null +++ b/test/regress/regress1/rels/bv1p-sat.cvc @@ -0,0 +1,22 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +BvPair: TYPE = [BITVECTOR(1), BITVECTOR(1)]; +x : SET OF BvPair; +y : SET OF BvPair; + +a : BvPair; +b : BvPair; +c : BvPair; +d : BvPair; + +ASSERT DISTINCT ( a, b ); +ASSERT DISTINCT ( c, d ); + +ASSERT a IS_IN x; +ASSERT b IS_IN x; +ASSERT a IS_IN y; +ASSERT b IS_IN y; +ASSERT NOT ( c IS_IN (x JOIN y)) AND NOT ( d IS_IN (x JOIN y)); + + +CHECKSAT; diff --git a/test/regress/regress1/rels/bv1p.cvc b/test/regress/regress1/rels/bv1p.cvc new file mode 100644 index 000000000..130ccae97 --- /dev/null +++ b/test/regress/regress1/rels/bv1p.cvc @@ -0,0 +1,22 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +BvPair: TYPE = [BITVECTOR(1), BITVECTOR(1)]; +x : SET OF BvPair; +y : SET OF BvPair; + +a : BvPair; +b : BvPair; +c : BvPair; +d : BvPair; +e : BvPair; + +ASSERT DISTINCT ( a, b ); +ASSERT DISTINCT ( c, d, e ); + +ASSERT a IS_IN x; +ASSERT b IS_IN x; +ASSERT a IS_IN y; +ASSERT b IS_IN y; +ASSERT (NOT ( c IS_IN (x JOIN y)) AND NOT ( d IS_IN (x JOIN y)) AND NOT ( e IS_IN (x JOIN y)) ); + +CHECKSAT; diff --git a/test/regress/regress1/rels/bv2.cvc b/test/regress/regress1/rels/bv2.cvc new file mode 100644 index 000000000..d7162de7c --- /dev/null +++ b/test/regress/regress1/rels/bv2.cvc @@ -0,0 +1,20 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +BvPair: TYPE = [BITVECTOR(2), BITVECTOR(2)]; +x : SET OF BvPair; +y : SET OF BvPair; + +a : BITVECTOR(2); +b : BITVECTOR(2); +c : BITVECTOR(2); +d : BITVECTOR(2); +e : BITVECTOR(2); + +ASSERT NOT ( b = c ); + +ASSERT (a, b) IS_IN x; +ASSERT (a, c) IS_IN x; +ASSERT (d, a) IS_IN y; +ASSERT NOT ( ( a, a ) IS_IN (x JOIN y)); + +CHECKSAT; diff --git a/test/regress/regress1/rels/garbage_collect.cvc b/test/regress/regress1/rels/garbage_collect.cvc new file mode 100644 index 000000000..1fc1f2fea --- /dev/null +++ b/test/regress/regress1/rels/garbage_collect.cvc @@ -0,0 +1,60 @@ +% EXPECT: unsat +H_TYPE: TYPE; +H: TYPE = [H_TYPE]; +Obj: TYPE; +Obj_Tup: TYPE = [Obj]; +MARK_TYPE: TYPE = [H_TYPE, Obj]; +RELATE: TYPE = [Obj, Obj]; +REF_TYPE: TYPE = [H_TYPE, Obj, Obj]; + +% Symbols h0 to h3 are constants of type H that represents the system state; +h0: SET OF H; +h1: SET OF H; +h2: SET OF H; +h3: SET OF H; +s0: H_TYPE; +s1: H_TYPE; +s2: H_TYPE; +s3: H_TYPE; +ASSERT h0 = {TUPLE(s0)}; +ASSERT h1 = {TUPLE(s1)}; +ASSERT h2 = {TUPLE(s2)}; +ASSERT h3 = {TUPLE(s3)}; + +% ref ⊆ H × Obj × Obj represents references between objects in each state; +ref : SET OF REF_TYPE; + +% mark ⊆ H × Obj represents the marked objects in each state +mark: SET OF MARK_TYPE; + +empty_obj_set: SET OF Obj_Tup; +ASSERT empty_obj_set = {}:: SET OF Obj_Tup; + +% root and live are two constants of type Obj that represents objects; +root: Obj; +live: Obj; + +% The state transition (h0–h1) resets all the marks +ASSERT (h1 JOIN mark) = empty_obj_set; +ASSERT (h0 JOIN ref) <= (h1 JOIN ref); + +% (h1–h2) marks objects reachable from root +ASSERT FORALL (n : Obj) : ((root, n) IS_IN TCLOSURE(h1 JOIN ref)) + => (TUPLE(n) IS_IN (h2 JOIN mark)); +ASSERT (h1 JOIN ref) <= (h2 JOIN ref); + +% (h2–h3) sweeps references of non-marked objects + +ASSERT FORALL (n: Obj) : (NOT (TUPLE(n) IS_IN (h2 JOIN mark))) + => ({TUPLE(n)} JOIN (h3 JOIN ref)) = empty_obj_set; + +ASSERT FORALL (n: Obj) : (TUPLE(n) IS_IN (h2 JOIN mark)) + => ({TUPLE(n)} JOIN (h3 JOIN ref)) = ({TUPLE(n)} JOIN (h2 JOIN ref)); + +%The safety property is negated, thus it checks if +%in the final state, there is a live object that was originally reachable from root +%in the beginning state, but some of its references have been swept +ASSERT (root, live) IS_IN TCLOSURE(h0 JOIN ref); +ASSERT NOT (({TUPLE(live)} JOIN (h0 JOIN ref)) <= ({TUPLE(live)} JOIN (h3 JOIN ref))); + +CHECKSAT;
\ No newline at end of file diff --git a/test/regress/regress1/rels/iden_1_1.cvc b/test/regress/regress1/rels/iden_1_1.cvc new file mode 100644 index 000000000..985a35a89 --- /dev/null +++ b/test/regress/regress1/rels/iden_1_1.cvc @@ -0,0 +1,22 @@ +% EXPECT: sat +OPTION "sets-ext"; +OPTION "logic" "ALL_SUPPORTED"; +Atom:TYPE; +AtomPair: TYPE = [Atom, Atom]; +x : SET OF AtomPair; +t : SET OF [Atom]; +univ : SET OF [Atom]; +univ2 : SET OF [Atom,Atom]; + +a : Atom; +b : Atom; +c : Atom; +d : Atom; +ASSERT univ = UNIVERSE::SET OF [Atom]; +ASSERT univ2 = UNIVERSE::SET OF [Atom, Atom]; +ASSERT univ2 = (univ PRODUCT univ); +ASSERT (a, b) IS_IN x; +ASSERT (c, d) IS_IN x; +ASSERT NOT(a = b); +ASSERT IDEN(univ) <= x; +CHECKSAT; diff --git a/test/regress/regress1/rels/join-eq-structure-and.cvc b/test/regress/regress1/rels/join-eq-structure-and.cvc new file mode 100644 index 000000000..177410b1e --- /dev/null +++ b/test/regress/regress1/rels/join-eq-structure-and.cvc @@ -0,0 +1,26 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +DATATYPE unit = u END; +IntUPair: TYPE = [INT, unit]; +UIntPair: TYPE = [unit, INT]; +w : SET OF IntUPair; +z : SET OF UIntPair; + +ASSERT (x JOIN y) = (w JOIN z) AND (x JOIN y ) = TRANSPOSE(w JOIN z); + +ASSERT (0,1) IS_IN (x JOIN y); + +t : INT; +ASSERT t >= 0 AND t <=1; +s : INT; +ASSERT s >= 0 AND s <=1; + +ASSERT s+t = 1; + +ASSERT ( s ,u ) IS_IN w; +ASSERT NOT ( u, t ) IS_IN z; + +CHECKSAT; diff --git a/test/regress/regress1/rels/join-eq-structure.cvc b/test/regress/regress1/rels/join-eq-structure.cvc new file mode 100644 index 000000000..e27d3811c --- /dev/null +++ b/test/regress/regress1/rels/join-eq-structure.cvc @@ -0,0 +1,26 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +DATATYPE unit = u END; +IntUPair: TYPE = [INT, unit]; +UIntPair: TYPE = [unit, INT]; +w : SET OF IntUPair; +z : SET OF UIntPair; + +ASSERT (x JOIN y) = (w JOIN z) OR (x JOIN y ) = TRANSPOSE(w JOIN z); + +ASSERT (0,1) IS_IN (x JOIN y); + +t : INT; +ASSERT t >= 0 AND t <=1; +s : INT; +ASSERT s >= 0 AND s <=1; + +ASSERT s+t = 1; + +ASSERT ( s ,u ) IS_IN w; +ASSERT NOT ( u, t ) IS_IN z; + +CHECKSAT; diff --git a/test/regress/regress1/rels/join-eq-structure_0_1.cvc b/test/regress/regress1/rels/join-eq-structure_0_1.cvc new file mode 100644 index 000000000..e27d3811c --- /dev/null +++ b/test/regress/regress1/rels/join-eq-structure_0_1.cvc @@ -0,0 +1,26 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +DATATYPE unit = u END; +IntUPair: TYPE = [INT, unit]; +UIntPair: TYPE = [unit, INT]; +w : SET OF IntUPair; +z : SET OF UIntPair; + +ASSERT (x JOIN y) = (w JOIN z) OR (x JOIN y ) = TRANSPOSE(w JOIN z); + +ASSERT (0,1) IS_IN (x JOIN y); + +t : INT; +ASSERT t >= 0 AND t <=1; +s : INT; +ASSERT s >= 0 AND s <=1; + +ASSERT s+t = 1; + +ASSERT ( s ,u ) IS_IN w; +ASSERT NOT ( u, t ) IS_IN z; + +CHECKSAT; diff --git a/test/regress/regress1/rels/joinImg_0_1.cvc b/test/regress/regress1/rels/joinImg_0_1.cvc new file mode 100644 index 000000000..4e69394bd --- /dev/null +++ b/test/regress/regress1/rels/joinImg_0_1.cvc @@ -0,0 +1,36 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +OPTION "sets-ext"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +r : SET OF IntPair; + +t : SET OF [INT]; +u : SET OF [INT]; + +z : IntPair; +ASSERT z = (1,2); +zt : IntPair; +ASSERT zt = (2,1); +v : IntPair; +ASSERT v = (1,1); +a : IntPair; +ASSERT a = (1,5); +b: INT; + +ASSERT (1, 7) IS_IN x; +ASSERT z IS_IN x; + +ASSERT (7, 5) IS_IN y; + +ASSERT t = (x JOIN_IMAGE 2); + +ASSERT TUPLE(3) IS_IN (x JOIN_IMAGE 2); + +ASSERT u = (x JOIN_IMAGE 1); + +ASSERT TUPLE(4) IS_IN (x JOIN_IMAGE 2); + +ASSERT TUPLE(b) IS_IN (x JOIN_IMAGE 1); +CHECKSAT; diff --git a/test/regress/regress1/rels/joinImg_0_2.cvc b/test/regress/regress1/rels/joinImg_0_2.cvc new file mode 100644 index 000000000..e15920804 --- /dev/null +++ b/test/regress/regress1/rels/joinImg_0_2.cvc @@ -0,0 +1,39 @@ +% EXPECT: sat +OPTION "sets-ext"; +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +r : SET OF IntPair; + +t : SET OF [INT]; +u : SET OF [INT]; +univ : SET OF [INT]; + +z : IntPair; +ASSERT z = (1,2); +zt : IntPair; +ASSERT zt = (2,1); +s : IntPair; +ASSERT s = (1,1); +a : IntPair; +ASSERT a = (1,5); +b: INT; + +ASSERT (1, 7) IS_IN x; +ASSERT z IS_IN x; + +ASSERT (7, 5) IS_IN y; + +ASSERT t = (x JOIN_IMAGE 2); +ASSERT univ = (x JOIN_IMAGE 0); +ASSERT TUPLE(100) IS_IN t; + +ASSERT NOT (TUPLE(3) IS_IN univ); + +ASSERT u = (x JOIN_IMAGE 1); + +ASSERT TUPLE(4) IS_IN (x JOIN_IMAGE 2); + +ASSERT TUPLE(b) IS_IN (x JOIN_IMAGE 1); +CHECKSAT; diff --git a/test/regress/regress1/rels/joinImg_1.cvc b/test/regress/regress1/rels/joinImg_1.cvc new file mode 100644 index 000000000..81f208fc4 --- /dev/null +++ b/test/regress/regress1/rels/joinImg_1.cvc @@ -0,0 +1,21 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +OPTION "sets-ext"; +Atom: TYPE; +x : SET OF [Atom, Atom]; +y : SET OF [Atom, Atom]; +r : SET OF [Atom, Atom]; + +t : SET OF [Atom]; + +a : Atom; +b : Atom; +c : Atom; +d : Atom; +e : Atom; + +ASSERT TUPLE(a) IS_IN (x JOIN_IMAGE 2); +ASSERT x = {(b, c), (d, e), (c, e)}; +ASSERT NOT(a = b); + +CHECKSAT; diff --git a/test/regress/regress1/rels/joinImg_1_1.cvc b/test/regress/regress1/rels/joinImg_1_1.cvc new file mode 100644 index 000000000..003770a1b --- /dev/null +++ b/test/regress/regress1/rels/joinImg_1_1.cvc @@ -0,0 +1,22 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +OPTION "sets-ext"; +Atom: TYPE; +x : SET OF [Atom, Atom]; +y : SET OF [Atom, Atom]; +r : SET OF [Atom, Atom]; + +t : SET OF [Atom]; + +a : Atom; +b : Atom; +c : Atom; +d : Atom; +e : Atom; + +ASSERT TUPLE(a) IS_IN (x JOIN_IMAGE 2); +ASSERT t = (x JOIN_IMAGE 2); +ASSERT x = {(b, c), (d, e), (c, e)}; +ASSERT TUPLE(c) IS_IN t; + +CHECKSAT; diff --git a/test/regress/regress1/rels/joinImg_2.cvc b/test/regress/regress1/rels/joinImg_2.cvc new file mode 100644 index 000000000..a4acfe6c6 --- /dev/null +++ b/test/regress/regress1/rels/joinImg_2.cvc @@ -0,0 +1,34 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +OPTION "sets-ext"; +Atom: TYPE; +x : SET OF [Atom, Atom]; +y : SET OF [Atom, Atom]; +r : SET OF [Atom, Atom]; + +t : SET OF [Atom]; + +a : Atom; +b : Atom; +c : Atom; +d : Atom; +e : Atom; +f : Atom; +g : Atom; + +ASSERT TUPLE(a) IS_IN (x JOIN_IMAGE 2); +ASSERT TUPLE(a) IS_IN (y JOIN_IMAGE 3); +%ASSERT y = {(f, g), (b, c), (d, e), (c, e)}; +ASSERT x = {(f, g), (b, c), (d, e), (c, e), (f, b)}; +ASSERT (a, f) IS_IN x; +ASSERT (a, f) IS_IN y; +ASSERT x = y; + + + +ASSERT NOT(a = b); + +ASSERT NOT (TUPLE(d) IS_IN (x JOIN_IMAGE 2)); +ASSERT f = d; + +CHECKSAT; diff --git a/test/regress/regress1/rels/joinImg_2_1.cvc b/test/regress/regress1/rels/joinImg_2_1.cvc new file mode 100644 index 000000000..03f88be37 --- /dev/null +++ b/test/regress/regress1/rels/joinImg_2_1.cvc @@ -0,0 +1,25 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +OPTION "sets-ext"; +Atom: TYPE; +x : SET OF [Atom, Atom]; +y : SET OF [Atom, Atom]; +r : SET OF [Atom, Atom]; + +t : SET OF [Atom]; + +a : Atom; +b : Atom; +c : Atom; +d : Atom; +e : Atom; +f : Atom; +g : Atom; + +ASSERT TUPLE(a) IS_IN (x JOIN_IMAGE 2); +ASSERT TUPLE(a) IS_IN (y JOIN_IMAGE 1); +ASSERT y = {(f, g), (b, c), (d, e), (c, e)}; +ASSERT x = {(f, g), (b, c), (d, e), (c, e)}; +ASSERT (NOT(a = b)) OR (NOT(a = f)); + +CHECKSAT; diff --git a/test/regress/regress1/rels/prod-mod-eq.cvc b/test/regress/regress1/rels/prod-mod-eq.cvc new file mode 100644 index 000000000..96ef2ffba --- /dev/null +++ b/test/regress/regress1/rels/prod-mod-eq.cvc @@ -0,0 +1,26 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +IntPairPair: TYPE = [INT, INT, INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPairPair; +z1 : SET OF IntPair; +w1 : SET OF IntPair; +z2 : SET OF IntPair; +w2 : SET OF IntPair; + +%ASSERT NOT (0,1,2,3) IS_IN (x PRODUCT y); + +ASSERT NOT( z = (x PRODUCT y) ); + +ASSERT (0,1,2,3) IS_IN z; + +ASSERT (0,1) IS_IN z1; +ASSERT (0,1) IS_IN z2; +ASSERT (2,3) IS_IN w1; +ASSERT (2,3) IS_IN w2; + +ASSERT ( x = z1 AND y = w1 ) OR ( x = z2 AND y = w2 ); + +CHECKSAT; diff --git a/test/regress/regress1/rels/prod-mod-eq2.cvc b/test/regress/regress1/rels/prod-mod-eq2.cvc new file mode 100644 index 000000000..b9341a216 --- /dev/null +++ b/test/regress/regress1/rels/prod-mod-eq2.cvc @@ -0,0 +1,26 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +IntPairPair: TYPE = [INT, INT, INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPairPair; +z1 : SET OF IntPair; +w1 : SET OF IntPair; +z2 : SET OF IntPair; +w2 : SET OF IntPair; +P : SET OF IntPairPair -> BOOLEAN; + +ASSERT z = (x PRODUCT y); + +ASSERT P( z ); +ASSERT NOT P( {(0,1,2,3)} ); + +ASSERT (0,1) IS_IN z1; +ASSERT (0,1) IS_IN z2; +ASSERT (2,3) IS_IN w1; +ASSERT (2,3) IS_IN w2; + +ASSERT ( x = z1 AND y = w1 ) OR ( x = z2 AND y = w2 ); + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_complex_3.cvc b/test/regress/regress1/rels/rel_complex_3.cvc new file mode 100644 index 000000000..492c94432 --- /dev/null +++ b/test/regress/regress1/rels/rel_complex_3.cvc @@ -0,0 +1,49 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +r : SET OF IntPair; +w : SET OF IntPair; + + +f : IntPair; +ASSERT f = (3,1); +ASSERT f IS_IN x; + +g : IntPair; +ASSERT g = (1,3); +ASSERT g IS_IN y; + +h : IntPair; +ASSERT h = (3,5); +ASSERT h IS_IN x; +ASSERT h IS_IN y; + +ASSERT r = (x JOIN y); + +e : IntPair; + +ASSERT NOT (e IS_IN r); +ASSERT NOT(z = (x & y)); +ASSERT z = (x - y); +ASSERT x <= y; +ASSERT e IS_IN (r JOIN z); +ASSERT e IS_IN x; +ASSERT e IS_IN (x & y); +CHECKSAT TRUE; + + + + + + + + + + + + + + diff --git a/test/regress/regress1/rels/rel_complex_4.cvc b/test/regress/regress1/rels/rel_complex_4.cvc new file mode 100644 index 000000000..f473b00aa --- /dev/null +++ b/test/regress/regress1/rels/rel_complex_4.cvc @@ -0,0 +1,52 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +r : SET OF IntPair; +w : SET OF IntPair; + + +f : IntPair; +ASSERT f = (3,1); +ASSERT f IS_IN x; + +g : IntPair; +ASSERT g = (1,3); +ASSERT g IS_IN y; + +h : IntPair; +ASSERT h = (3,5); +ASSERT h IS_IN x; +ASSERT h IS_IN y; + +ASSERT r = (x JOIN y); +a:INT; +e : IntPair; +ASSERT e = (a,a); +ASSERT w = {e}; +ASSERT TRANSPOSE(w) <= y; + +ASSERT NOT (e IS_IN r); +ASSERT NOT(z = (x & y)); +ASSERT z = (x - y); +ASSERT x <= y; +ASSERT e IS_IN (r JOIN z); +ASSERT e IS_IN x; +ASSERT e IS_IN (x & y); +CHECKSAT TRUE; + + + + + + + + + + + + + + diff --git a/test/regress/regress1/rels/rel_complex_5.cvc b/test/regress/regress1/rels/rel_complex_5.cvc new file mode 100644 index 000000000..d64817187 --- /dev/null +++ b/test/regress/regress1/rels/rel_complex_5.cvc @@ -0,0 +1,55 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +IntTup: TYPE = [INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +r : SET OF IntPair; +w : SET OF IntPair; + + +f : IntPair; +ASSERT f = (3,1); +ASSERT f IS_IN x; + +g : IntPair; +ASSERT g = (1,3); +ASSERT g IS_IN y; + +h : IntPair; +ASSERT h = (3,5); +ASSERT h IS_IN x; +ASSERT h IS_IN y; + +ASSERT r = (x JOIN y); +a:IntTup; +ASSERT a = TUPLE(1); +e : IntPair; +ASSERT e = (1,1); + +ASSERT w = ({a} PRODUCT {a}); +ASSERT TRANSPOSE(w) <= y; + +ASSERT NOT (e IS_IN r); +ASSERT NOT(z = (x & y)); +ASSERT z = (x - y); +ASSERT x <= y; +ASSERT e IS_IN (r JOIN z); +ASSERT e IS_IN x; +ASSERT e IS_IN (x & y); +CHECKSAT TRUE; + + + + + + + + + + + + + + diff --git a/test/regress/regress1/rels/rel_mix_0_1.cvc b/test/regress/regress1/rels/rel_mix_0_1.cvc new file mode 100644 index 000000000..723a9b2e2 --- /dev/null +++ b/test/regress/regress1/rels/rel_mix_0_1.cvc @@ -0,0 +1,30 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +IntTup: TYPE = [INT]; +x : SET OF IntPair; +y : SET OF IntPair; +r : SET OF IntPair; + +w : SET OF IntTup; +z : SET OF IntTup; +r2 : SET OF IntPair; + +d : IntPair; +ASSERT d = (1,3); +ASSERT (1,3) IS_IN y; + +a : IntPair; +ASSERT a IS_IN x; + +e : IntPair; +ASSERT e = (4,3); + +ASSERT r = (x JOIN y); +ASSERT r2 = (w PRODUCT z); + +ASSERT NOT (e IS_IN r); +%ASSERT e IS_IN r2; +ASSERT NOT (r = r2); + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_pressure_0.cvc b/test/regress/regress1/rels/rel_pressure_0.cvc new file mode 100644 index 000000000..6cdf03600 --- /dev/null +++ b/test/regress/regress1/rels/rel_pressure_0.cvc @@ -0,0 +1,617 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +r : SET OF IntPair; + +a11 : IntPair; +ASSERT a11 = (1, 1); +ASSERT a11 IS_IN x; +a12 : IntPair; +ASSERT a12 = (1, 2); +ASSERT a12 IS_IN x; +a13 : IntPair; +ASSERT a13 = (1, 3); +ASSERT a13 IS_IN x; +a14 : IntPair; +ASSERT a14 = (1, 4); +ASSERT a14 IS_IN x; +a15 : IntPair; +ASSERT a15 = (1, 5); +ASSERT a15 IS_IN x; +a16 : IntPair; +ASSERT a16 = (1, 6); +ASSERT a16 IS_IN x; +a17 : IntPair; +ASSERT a17 = (1, 7); +ASSERT a17 IS_IN x; +a18 : IntPair; +ASSERT a18 = (1, 8); +ASSERT a18 IS_IN x; +a19 : IntPair; +ASSERT a19 = (1, 9); +ASSERT a19 IS_IN x; +a110 : IntPair; +ASSERT a110 = (1, 10); +ASSERT a110 IS_IN x; +a21 : IntPair; +ASSERT a21 = (2, 1); +ASSERT a21 IS_IN x; +a22 : IntPair; +ASSERT a22 = (2, 2); +ASSERT a22 IS_IN x; +a23 : IntPair; +ASSERT a23 = (2, 3); +ASSERT a23 IS_IN x; +a24 : IntPair; +ASSERT a24 = (2, 4); +ASSERT a24 IS_IN x; +a25 : IntPair; +ASSERT a25 = (2, 5); +ASSERT a25 IS_IN x; +a26 : IntPair; +ASSERT a26 = (2, 6); +ASSERT a26 IS_IN x; +a27 : IntPair; +ASSERT a27 = (2, 7); +ASSERT a27 IS_IN x; +a28 : IntPair; +ASSERT a28 = (2, 8); +ASSERT a28 IS_IN x; +a29 : IntPair; +ASSERT a29 = (2, 9); +ASSERT a29 IS_IN x; +a210 : IntPair; +ASSERT a210 = (2, 10); +ASSERT a210 IS_IN x; +a31 : IntPair; +ASSERT a31 = (3, 1); +ASSERT a31 IS_IN x; +a32 : IntPair; +ASSERT a32 = (3, 2); +ASSERT a32 IS_IN x; +a33 : IntPair; +ASSERT a33 = (3, 3); +ASSERT a33 IS_IN x; +a34 : IntPair; +ASSERT a34 = (3, 4); +ASSERT a34 IS_IN x; +a35 : IntPair; +ASSERT a35 = (3, 5); +ASSERT a35 IS_IN x; +a36 : IntPair; +ASSERT a36 = (3, 6); +ASSERT a36 IS_IN x; +a37 : IntPair; +ASSERT a37 = (3, 7); +ASSERT a37 IS_IN x; +a38 : IntPair; +ASSERT a38 = (3, 8); +ASSERT a38 IS_IN x; +a39 : IntPair; +ASSERT a39 = (3, 9); +ASSERT a39 IS_IN x; +a310 : IntPair; +ASSERT a310 = (3, 10); +ASSERT a310 IS_IN x; +a41 : IntPair; +ASSERT a41 = (4, 1); +ASSERT a41 IS_IN x; +a42 : IntPair; +ASSERT a42 = (4, 2); +ASSERT a42 IS_IN x; +a43 : IntPair; +ASSERT a43 = (4, 3); +ASSERT a43 IS_IN x; +a44 : IntPair; +ASSERT a44 = (4, 4); +ASSERT a44 IS_IN x; +a45 : IntPair; +ASSERT a45 = (4, 5); +ASSERT a45 IS_IN x; +a46 : IntPair; +ASSERT a46 = (4, 6); +ASSERT a46 IS_IN x; +a47 : IntPair; +ASSERT a47 = (4, 7); +ASSERT a47 IS_IN x; +a48 : IntPair; +ASSERT a48 = (4, 8); +ASSERT a48 IS_IN x; +a49 : IntPair; +ASSERT a49 = (4, 9); +ASSERT a49 IS_IN x; +a410 : IntPair; +ASSERT a410 = (4, 10); +ASSERT a410 IS_IN x; +a51 : IntPair; +ASSERT a51 = (5, 1); +ASSERT a51 IS_IN x; +a52 : IntPair; +ASSERT a52 = (5, 2); +ASSERT a52 IS_IN x; +a53 : IntPair; +ASSERT a53 = (5, 3); +ASSERT a53 IS_IN x; +a54 : IntPair; +ASSERT a54 = (5, 4); +ASSERT a54 IS_IN x; +a55 : IntPair; +ASSERT a55 = (5, 5); +ASSERT a55 IS_IN x; +a56 : IntPair; +ASSERT a56 = (5, 6); +ASSERT a56 IS_IN x; +a57 : IntPair; +ASSERT a57 = (5, 7); +ASSERT a57 IS_IN x; +a58 : IntPair; +ASSERT a58 = (5, 8); +ASSERT a58 IS_IN x; +a59 : IntPair; +ASSERT a59 = (5, 9); +ASSERT a59 IS_IN x; +a510 : IntPair; +ASSERT a510 = (5, 10); +ASSERT a510 IS_IN x; +a61 : IntPair; +ASSERT a61 = (6, 1); +ASSERT a61 IS_IN x; +a62 : IntPair; +ASSERT a62 = (6, 2); +ASSERT a62 IS_IN x; +a63 : IntPair; +ASSERT a63 = (6, 3); +ASSERT a63 IS_IN x; +a64 : IntPair; +ASSERT a64 = (6, 4); +ASSERT a64 IS_IN x; +a65 : IntPair; +ASSERT a65 = (6, 5); +ASSERT a65 IS_IN x; +a66 : IntPair; +ASSERT a66 = (6, 6); +ASSERT a66 IS_IN x; +a67 : IntPair; +ASSERT a67 = (6, 7); +ASSERT a67 IS_IN x; +a68 : IntPair; +ASSERT a68 = (6, 8); +ASSERT a68 IS_IN x; +a69 : IntPair; +ASSERT a69 = (6, 9); +ASSERT a69 IS_IN x; +a610 : IntPair; +ASSERT a610 = (6, 10); +ASSERT a610 IS_IN x; +a71 : IntPair; +ASSERT a71 = (7, 1); +ASSERT a71 IS_IN x; +a72 : IntPair; +ASSERT a72 = (7, 2); +ASSERT a72 IS_IN x; +a73 : IntPair; +ASSERT a73 = (7, 3); +ASSERT a73 IS_IN x; +a74 : IntPair; +ASSERT a74 = (7, 4); +ASSERT a74 IS_IN x; +a75 : IntPair; +ASSERT a75 = (7, 5); +ASSERT a75 IS_IN x; +a76 : IntPair; +ASSERT a76 = (7, 6); +ASSERT a76 IS_IN x; +a77 : IntPair; +ASSERT a77 = (7, 7); +ASSERT a77 IS_IN x; +a78 : IntPair; +ASSERT a78 = (7, 8); +ASSERT a78 IS_IN x; +a79 : IntPair; +ASSERT a79 = (7, 9); +ASSERT a79 IS_IN x; +a710 : IntPair; +ASSERT a710 = (7, 10); +ASSERT a710 IS_IN x; +a81 : IntPair; +ASSERT a81 = (8, 1); +ASSERT a81 IS_IN x; +a82 : IntPair; +ASSERT a82 = (8, 2); +ASSERT a82 IS_IN x; +a83 : IntPair; +ASSERT a83 = (8, 3); +ASSERT a83 IS_IN x; +a84 : IntPair; +ASSERT a84 = (8, 4); +ASSERT a84 IS_IN x; +a85 : IntPair; +ASSERT a85 = (8, 5); +ASSERT a85 IS_IN x; +a86 : IntPair; +ASSERT a86 = (8, 6); +ASSERT a86 IS_IN x; +a87 : IntPair; +ASSERT a87 = (8, 7); +ASSERT a87 IS_IN x; +a88 : IntPair; +ASSERT a88 = (8, 8); +ASSERT a88 IS_IN x; +a89 : IntPair; +ASSERT a89 = (8, 9); +ASSERT a89 IS_IN x; +a810 : IntPair; +ASSERT a810 = (8, 10); +ASSERT a810 IS_IN x; +a91 : IntPair; +ASSERT a91 = (9, 1); +ASSERT a91 IS_IN x; +a92 : IntPair; +ASSERT a92 = (9, 2); +ASSERT a92 IS_IN x; +a93 : IntPair; +ASSERT a93 = (9, 3); +ASSERT a93 IS_IN x; +a94 : IntPair; +ASSERT a94 = (9, 4); +ASSERT a94 IS_IN x; +a95 : IntPair; +ASSERT a95 = (9, 5); +ASSERT a95 IS_IN x; +a96 : IntPair; +ASSERT a96 = (9, 6); +ASSERT a96 IS_IN x; +a97 : IntPair; +ASSERT a97 = (9, 7); +ASSERT a97 IS_IN x; +a98 : IntPair; +ASSERT a98 = (9, 8); +ASSERT a98 IS_IN x; +a99 : IntPair; +ASSERT a99 = (9, 9); +ASSERT a99 IS_IN x; +a910 : IntPair; +ASSERT a910 = (9, 10); +ASSERT a910 IS_IN x; +a101 : IntPair; +ASSERT a101 = (10, 1); +ASSERT a101 IS_IN x; +a102 : IntPair; +ASSERT a102 = (10, 2); +ASSERT a102 IS_IN x; +a103 : IntPair; +ASSERT a103 = (10, 3); +ASSERT a103 IS_IN x; +a104 : IntPair; +ASSERT a104 = (10, 4); +ASSERT a104 IS_IN x; +a105 : IntPair; +ASSERT a105 = (10, 5); +ASSERT a105 IS_IN x; +a106 : IntPair; +ASSERT a106 = (10, 6); +ASSERT a106 IS_IN x; +a107 : IntPair; +ASSERT a107 = (10, 7); +ASSERT a107 IS_IN x; +a108 : IntPair; +ASSERT a108 = (10, 8); +ASSERT a108 IS_IN x; +a109 : IntPair; +ASSERT a109 = (10, 9); +ASSERT a109 IS_IN x; +a1010 : IntPair; +ASSERT a1010 = (10, 10); +ASSERT a1010 IS_IN x; +b11 : IntPair; +ASSERT b11 = (1, 1); +ASSERT b11 IS_IN y; +b12 : IntPair; +ASSERT b12 = (1, 2); +ASSERT b12 IS_IN y; +b13 : IntPair; +ASSERT b13 = (1, 3); +ASSERT b13 IS_IN y; +b14 : IntPair; +ASSERT b14 = (1, 4); +ASSERT b14 IS_IN y; +b15 : IntPair; +ASSERT b15 = (1, 5); +ASSERT b15 IS_IN y; +b16 : IntPair; +ASSERT b16 = (1, 6); +ASSERT b16 IS_IN y; +b17 : IntPair; +ASSERT b17 = (1, 7); +ASSERT b17 IS_IN y; +b18 : IntPair; +ASSERT b18 = (1, 8); +ASSERT b18 IS_IN y; +b19 : IntPair; +ASSERT b19 = (1, 9); +ASSERT b19 IS_IN y; +b110 : IntPair; +ASSERT b110 = (1, 10); +ASSERT b110 IS_IN y; +b21 : IntPair; +ASSERT b21 = (2, 1); +ASSERT b21 IS_IN y; +b22 : IntPair; +ASSERT b22 = (2, 2); +ASSERT b22 IS_IN y; +b23 : IntPair; +ASSERT b23 = (2, 3); +ASSERT b23 IS_IN y; +b24 : IntPair; +ASSERT b24 = (2, 4); +ASSERT b24 IS_IN y; +b25 : IntPair; +ASSERT b25 = (2, 5); +ASSERT b25 IS_IN y; +b26 : IntPair; +ASSERT b26 = (2, 6); +ASSERT b26 IS_IN y; +b27 : IntPair; +ASSERT b27 = (2, 7); +ASSERT b27 IS_IN y; +b28 : IntPair; +ASSERT b28 = (2, 8); +ASSERT b28 IS_IN y; +b29 : IntPair; +ASSERT b29 = (2, 9); +ASSERT b29 IS_IN y; +b210 : IntPair; +ASSERT b210 = (2, 10); +ASSERT b210 IS_IN y; +b31 : IntPair; +ASSERT b31 = (3, 1); +ASSERT b31 IS_IN y; +b32 : IntPair; +ASSERT b32 = (3, 2); +ASSERT b32 IS_IN y; +b33 : IntPair; +ASSERT b33 = (3, 3); +ASSERT b33 IS_IN y; +b34 : IntPair; +ASSERT b34 = (3, 4); +ASSERT b34 IS_IN y; +b35 : IntPair; +ASSERT b35 = (3, 5); +ASSERT b35 IS_IN y; +b36 : IntPair; +ASSERT b36 = (3, 6); +ASSERT b36 IS_IN y; +b37 : IntPair; +ASSERT b37 = (3, 7); +ASSERT b37 IS_IN y; +b38 : IntPair; +ASSERT b38 = (3, 8); +ASSERT b38 IS_IN y; +b39 : IntPair; +ASSERT b39 = (3, 9); +ASSERT b39 IS_IN y; +b310 : IntPair; +ASSERT b310 = (3, 10); +ASSERT b310 IS_IN y; +b41 : IntPair; +ASSERT b41 = (4, 1); +ASSERT b41 IS_IN y; +b42 : IntPair; +ASSERT b42 = (4, 2); +ASSERT b42 IS_IN y; +b43 : IntPair; +ASSERT b43 = (4, 3); +ASSERT b43 IS_IN y; +b44 : IntPair; +ASSERT b44 = (4, 4); +ASSERT b44 IS_IN y; +b45 : IntPair; +ASSERT b45 = (4, 5); +ASSERT b45 IS_IN y; +b46 : IntPair; +ASSERT b46 = (4, 6); +ASSERT b46 IS_IN y; +b47 : IntPair; +ASSERT b47 = (4, 7); +ASSERT b47 IS_IN y; +b48 : IntPair; +ASSERT b48 = (4, 8); +ASSERT b48 IS_IN y; +b49 : IntPair; +ASSERT b49 = (4, 9); +ASSERT b49 IS_IN y; +b410 : IntPair; +ASSERT b410 = (4, 10); +ASSERT b410 IS_IN y; +b51 : IntPair; +ASSERT b51 = (5, 1); +ASSERT b51 IS_IN y; +b52 : IntPair; +ASSERT b52 = (5, 2); +ASSERT b52 IS_IN y; +b53 : IntPair; +ASSERT b53 = (5, 3); +ASSERT b53 IS_IN y; +b54 : IntPair; +ASSERT b54 = (5, 4); +ASSERT b54 IS_IN y; +b55 : IntPair; +ASSERT b55 = (5, 5); +ASSERT b55 IS_IN y; +b56 : IntPair; +ASSERT b56 = (5, 6); +ASSERT b56 IS_IN y; +b57 : IntPair; +ASSERT b57 = (5, 7); +ASSERT b57 IS_IN y; +b58 : IntPair; +ASSERT b58 = (5, 8); +ASSERT b58 IS_IN y; +b59 : IntPair; +ASSERT b59 = (5, 9); +ASSERT b59 IS_IN y; +b510 : IntPair; +ASSERT b510 = (5, 10); +ASSERT b510 IS_IN y; +b61 : IntPair; +ASSERT b61 = (6, 1); +ASSERT b61 IS_IN y; +b62 : IntPair; +ASSERT b62 = (6, 2); +ASSERT b62 IS_IN y; +b63 : IntPair; +ASSERT b63 = (6, 3); +ASSERT b63 IS_IN y; +b64 : IntPair; +ASSERT b64 = (6, 4); +ASSERT b64 IS_IN y; +b65 : IntPair; +ASSERT b65 = (6, 5); +ASSERT b65 IS_IN y; +b66 : IntPair; +ASSERT b66 = (6, 6); +ASSERT b66 IS_IN y; +b67 : IntPair; +ASSERT b67 = (6, 7); +ASSERT b67 IS_IN y; +b68 : IntPair; +ASSERT b68 = (6, 8); +ASSERT b68 IS_IN y; +b69 : IntPair; +ASSERT b69 = (6, 9); +ASSERT b69 IS_IN y; +b610 : IntPair; +ASSERT b610 = (6, 10); +ASSERT b610 IS_IN y; +b71 : IntPair; +ASSERT b71 = (7, 1); +ASSERT b71 IS_IN y; +b72 : IntPair; +ASSERT b72 = (7, 2); +ASSERT b72 IS_IN y; +b73 : IntPair; +ASSERT b73 = (7, 3); +ASSERT b73 IS_IN y; +b74 : IntPair; +ASSERT b74 = (7, 4); +ASSERT b74 IS_IN y; +b75 : IntPair; +ASSERT b75 = (7, 5); +ASSERT b75 IS_IN y; +b76 : IntPair; +ASSERT b76 = (7, 6); +ASSERT b76 IS_IN y; +b77 : IntPair; +ASSERT b77 = (7, 7); +ASSERT b77 IS_IN y; +b78 : IntPair; +ASSERT b78 = (7, 8); +ASSERT b78 IS_IN y; +b79 : IntPair; +ASSERT b79 = (7, 9); +ASSERT b79 IS_IN y; +b710 : IntPair; +ASSERT b710 = (7, 10); +ASSERT b710 IS_IN y; +b81 : IntPair; +ASSERT b81 = (8, 1); +ASSERT b81 IS_IN y; +b82 : IntPair; +ASSERT b82 = (8, 2); +ASSERT b82 IS_IN y; +b83 : IntPair; +ASSERT b83 = (8, 3); +ASSERT b83 IS_IN y; +b84 : IntPair; +ASSERT b84 = (8, 4); +ASSERT b84 IS_IN y; +b85 : IntPair; +ASSERT b85 = (8, 5); +ASSERT b85 IS_IN y; +b86 : IntPair; +ASSERT b86 = (8, 6); +ASSERT b86 IS_IN y; +b87 : IntPair; +ASSERT b87 = (8, 7); +ASSERT b87 IS_IN y; +b88 : IntPair; +ASSERT b88 = (8, 8); +ASSERT b88 IS_IN y; +b89 : IntPair; +ASSERT b89 = (8, 9); +ASSERT b89 IS_IN y; +b810 : IntPair; +ASSERT b810 = (8, 10); +ASSERT b810 IS_IN y; +b91 : IntPair; +ASSERT b91 = (9, 1); +ASSERT b91 IS_IN y; +b92 : IntPair; +ASSERT b92 = (9, 2); +ASSERT b92 IS_IN y; +b93 : IntPair; +ASSERT b93 = (9, 3); +ASSERT b93 IS_IN y; +b94 : IntPair; +ASSERT b94 = (9, 4); +ASSERT b94 IS_IN y; +b95 : IntPair; +ASSERT b95 = (9, 5); +ASSERT b95 IS_IN y; +b96 : IntPair; +ASSERT b96 = (9, 6); +ASSERT b96 IS_IN y; +b97 : IntPair; +ASSERT b97 = (9, 7); +ASSERT b97 IS_IN y; +b98 : IntPair; +ASSERT b98 = (9, 8); +ASSERT b98 IS_IN y; +b99 : IntPair; +ASSERT b99 = (9, 9); +ASSERT b99 IS_IN y; +b910 : IntPair; +ASSERT b910 = (9, 10); +ASSERT b910 IS_IN y; +b101 : IntPair; +ASSERT b101 = (10, 1); +ASSERT b101 IS_IN y; +b102 : IntPair; +ASSERT b102 = (10, 2); +ASSERT b102 IS_IN y; +b103 : IntPair; +ASSERT b103 = (10, 3); +ASSERT b103 IS_IN y; +b104 : IntPair; +ASSERT b104 = (10, 4); +ASSERT b104 IS_IN y; +b105 : IntPair; +ASSERT b105 = (10, 5); +ASSERT b105 IS_IN y; +b106 : IntPair; +ASSERT b106 = (10, 6); +ASSERT b106 IS_IN y; +b107 : IntPair; +ASSERT b107 = (10, 7); +ASSERT b107 IS_IN y; +b108 : IntPair; +ASSERT b108 = (10, 8); +ASSERT b108 IS_IN y; +b109 : IntPair; +ASSERT b109 = (10, 9); +ASSERT b109 IS_IN y; +b1010 : IntPair; +ASSERT b1010 = (10, 10); +ASSERT b1010 IS_IN y; + +ASSERT (1, 9) IS_IN z; + +a : IntPair; +ASSERT a = (9,1); +ASSERT r = (((TRANSPOSE x) JOIN y) JOIN z); +ASSERT NOT (a IS_IN (TRANSPOSE r)); + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_tc_10_1.cvc b/test/regress/regress1/rels/rel_tc_10_1.cvc new file mode 100644 index 000000000..67c444070 --- /dev/null +++ b/test/regress/regress1/rels/rel_tc_10_1.cvc @@ -0,0 +1,18 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +a: INT; +b:INT; +c:INT; +d:INT; +ASSERT a = c; +ASSERT a = d; +ASSERT (1, c) IS_IN x; +ASSERT (2, d) IS_IN x; +ASSERT (a, 5) IS_IN y; +ASSERT y = (TCLOSURE x); +ASSERT ((2, 5) IS_IN y); + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_tc_4.cvc b/test/regress/regress1/rels/rel_tc_4.cvc new file mode 100644 index 000000000..decd38fe1 --- /dev/null +++ b/test/regress/regress1/rels/rel_tc_4.cvc @@ -0,0 +1,19 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +a: INT; +b:INT; +c:INT; +d:INT; +ASSERT (1, a) IS_IN x; +ASSERT (1, c) IS_IN x; +ASSERT (1, d) IS_IN x; +ASSERT (b, 1) IS_IN x; +ASSERT (b = d); +ASSERT (2,b) IS_IN ((x JOIN x) JOIN x); +ASSERT NOT (2, 1) IS_IN (TCLOSURE x); + + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_tc_4_1.cvc b/test/regress/regress1/rels/rel_tc_4_1.cvc new file mode 100644 index 000000000..8ee75f7e9 --- /dev/null +++ b/test/regress/regress1/rels/rel_tc_4_1.cvc @@ -0,0 +1,10 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +ASSERT y = ((TCLOSURE x) JOIN x); +ASSERT NOT (y = TCLOSURE x); + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_tc_5_1.cvc b/test/regress/regress1/rels/rel_tc_5_1.cvc new file mode 100644 index 000000000..fd9caeade --- /dev/null +++ b/test/regress/regress1/rels/rel_tc_5_1.cvc @@ -0,0 +1,9 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +ASSERT y = (TCLOSURE x); +ASSERT NOT ( y = ((x JOIN x) JOIN x)); + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_tc_6.cvc b/test/regress/regress1/rels/rel_tc_6.cvc new file mode 100644 index 000000000..4570c5a8d --- /dev/null +++ b/test/regress/regress1/rels/rel_tc_6.cvc @@ -0,0 +1,9 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +ASSERT y = (TCLOSURE x); +ASSERT NOT (((x JOIN x) JOIN x) <= y); + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_tc_9_1.cvc b/test/regress/regress1/rels/rel_tc_9_1.cvc new file mode 100644 index 000000000..f884349b1 --- /dev/null +++ b/test/regress/regress1/rels/rel_tc_9_1.cvc @@ -0,0 +1,23 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +w : SET OF IntPair; + +ASSERT z = (TCLOSURE x); +ASSERT w = (x JOIN y); +ASSERT (2, 2) IS_IN z; +ASSERT (0,3) IS_IN y; +ASSERT (-1,3) IS_IN y; +ASSERT (1,3) IS_IN y; +ASSERT (-2,3) IS_IN y; +ASSERT (2,3) IS_IN y; +ASSERT (3,3) IS_IN y; +ASSERT (4,3) IS_IN y; +ASSERT (5,3) IS_IN y; +ASSERT NOT (2, 3) IS_IN (x JOIN y); +ASSERT NOT (2,1) IS_IN x; + +CHECKSAT; diff --git a/test/regress/regress1/rels/rel_tp_2.cvc b/test/regress/regress1/rels/rel_tp_2.cvc new file mode 100644 index 000000000..441e79c45 --- /dev/null +++ b/test/regress/regress1/rels/rel_tp_2.cvc @@ -0,0 +1,10 @@ +% EXPECT: unsat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +ASSERT (z = TRANSPOSE(y) OR z = TRANSPOSE(x)); +ASSERT NOT (TRANSPOSE(z) = y); +ASSERT NOT (TRANSPOSE(z) = x); +CHECKSAT;
\ No newline at end of file diff --git a/test/regress/regress1/rels/rel_tp_join_2_1.cvc b/test/regress/regress1/rels/rel_tp_join_2_1.cvc new file mode 100644 index 000000000..acf3dbccf --- /dev/null +++ b/test/regress/regress1/rels/rel_tp_join_2_1.cvc @@ -0,0 +1,19 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [INT, INT]; +x : SET OF IntPair; +y : SET OF IntPair; +z : SET OF IntPair; +r : SET OF IntPair; +ASSERT (7, 1) IS_IN x; +ASSERT (2, 3) IS_IN x; + +ASSERT (7, 3) IS_IN y; +ASSERT (4, 7) IS_IN y; +ASSERT (3, 4) IS_IN z; +a : IntPair; +ASSERT a = (4,1); + +ASSERT r = (((TRANSPOSE x) JOIN y) JOIN z); +ASSERT a IS_IN (TRANSPOSE r); +CHECKSAT; diff --git a/test/regress/regress1/rels/set-strat.cvc b/test/regress/regress1/rels/set-strat.cvc new file mode 100644 index 000000000..0dee0e84d --- /dev/null +++ b/test/regress/regress1/rels/set-strat.cvc @@ -0,0 +1,24 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [ INT, INT]; +SetIntPair: TYPE = [ SET OF IntPair, SET OF IntPair ]; +x : SET OF IntPair; +y : SET OF IntPair; +w : SET OF IntPair; +z : SET OF SetIntPair; + +a : IntPair; +b : IntPair; + +ASSERT NOT a = b; + +ASSERT a IS_IN x; +ASSERT b IS_IN y; +ASSERT b IS_IN w; +ASSERT (x,y) IS_IN z; +ASSERT (w,x) IS_IN z; +ASSERT NOT ( (x,x) IS_IN (z JOIN z) ); + +ASSERT (x, { ( 0, 0 ) } ) IS_IN (z JOIN z); + +CHECKSAT; diff --git a/test/regress/regress1/rels/strat.cvc b/test/regress/regress1/rels/strat.cvc new file mode 100644 index 000000000..b91ddbbe8 --- /dev/null +++ b/test/regress/regress1/rels/strat.cvc @@ -0,0 +1,24 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [ INT, INT]; +IntIntPair: TYPE = [ IntPair, IntPair]; +x : SET OF IntIntPair; +y : SET OF IntIntPair; +z : SET OF IntPair; +w : SET OF IntPair; + +a : IntPair; +b : IntPair; +c : IntIntPair; + +ASSERT NOT a = b; + +ASSERT a IS_IN z; +ASSERT b IS_IN z; +ASSERT (a,b) IS_IN x; +ASSERT (b,a) IS_IN x; +ASSERT c IS_IN x; +ASSERT NOT ( c = (a,b) ) AND NOT ( c = (b,a) ); + + +CHECKSAT; diff --git a/test/regress/regress1/rels/strat_0_1.cvc b/test/regress/regress1/rels/strat_0_1.cvc new file mode 100644 index 000000000..b91ddbbe8 --- /dev/null +++ b/test/regress/regress1/rels/strat_0_1.cvc @@ -0,0 +1,24 @@ +% EXPECT: sat +OPTION "logic" "ALL_SUPPORTED"; +IntPair: TYPE = [ INT, INT]; +IntIntPair: TYPE = [ IntPair, IntPair]; +x : SET OF IntIntPair; +y : SET OF IntIntPair; +z : SET OF IntPair; +w : SET OF IntPair; + +a : IntPair; +b : IntPair; +c : IntIntPair; + +ASSERT NOT a = b; + +ASSERT a IS_IN z; +ASSERT b IS_IN z; +ASSERT (a,b) IS_IN x; +ASSERT (b,a) IS_IN x; +ASSERT c IS_IN x; +ASSERT NOT ( c = (a,b) ) AND NOT ( c = (b,a) ); + + +CHECKSAT; diff --git a/test/regress/regress1/rewriterules/Makefile.am b/test/regress/regress1/rewriterules/Makefile.am index a5a045d2e..fbf3db47a 100644 --- a/test/regress/regress1/rewriterules/Makefile.am +++ b/test/regress/regress1/rewriterules/Makefile.am @@ -23,9 +23,31 @@ MAKEFLAGS = -k # put it below in "TESTS +=" TESTS = \ reachability_back_to_the_future.smt2 \ - read5.smt2 - -EXTRA_DIST = $(TESTS) + read5.smt2 \ + length_gen.smt2 \ + length_gen_020.smt2 \ + length_gen_020_sat.smt2 \ + length_gen_040.smt2 \ + length_gen_040_lemma.smt2 \ + length_gen_040_lemma_trigger.smt2 \ + datatypes_sat.smt2 + + +EXTRA_DIST = $(TESTS) \ + datatypes_clark_quantification.smt2 \ + datatypes2.smt2 \ + datatypes3.smt2 \ + length_gen_010_lemma.smt2 \ + length_gen_010.smt2 \ + length_gen_080.smt2 \ + length_gen_160_lemma.smt2 \ + length_gen_inv_160.smt2 \ + length_trick3_int.smt2 \ + length_trick3.smt2 \ + set_A_new_fast_tableau-base_sat.smt2 \ + set_A_new_fast_tableau-base.smt2 \ + test_guards.smt2 \ + why3_vstte10_max_sum_harness2.smt2 # synonyms for "check" in this directory .PHONY: regress regress1 test diff --git a/test/regress/regress1/rewriterules/datatypes2.smt2 b/test/regress/regress1/rewriterules/datatypes2.smt2 new file mode 100644 index 000000000..277ddc3ae --- /dev/null +++ b/test/regress/regress1/rewriterules/datatypes2.smt2 @@ -0,0 +1,150 @@ +;; try to solve datatypes with rewriterules +(set-logic AUFLIA) +(set-info :status unsat) + +;; lists 2 nil +(declare-sort elt 0) ;; we suppose that elt is infinite +(declare-sort list 0) + +(declare-fun nil1 () list) +(declare-fun nil2 () list) +(declare-fun cons1 (elt list) list) +(declare-fun cons2 (elt list) list) + +;;;;;;;;;;;;;;;;;;;; +;; injective + +(declare-fun inj11 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj11 (cons1 ?e ?l)) ?e))) :pattern ((cons1 ?e ?l)) ) :rewrite-rule) )) + +(declare-fun inj12 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj12 (cons1 ?e ?l)) ?l))) :pattern ((cons1 ?e ?l)) ) :rewrite-rule) )) + +(declare-fun inj21 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj21 (cons2 ?e ?l)) ?e))) :pattern ((cons2 ?e ?l)) ) :rewrite-rule) )) + +(declare-fun inj22 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj22 (cons2 ?e ?l)) ?l))) :pattern ((cons2 ?e ?l)) ) :rewrite-rule) )) + + +;;;;;;;;;;;;;;;;;;;; +;; projection + +(declare-fun proj11 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (= (proj11 (cons1 ?e ?l)) ?e) :rewrite-rule) )) + +(declare-fun proj12 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (= (proj12 (cons1 ?e ?l)) ?l) :rewrite-rule) )) + + +(declare-fun proj21 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (= (proj21 (cons2 ?e ?l)) ?e) :rewrite-rule) )) + +(declare-fun proj22 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (= (proj22 (cons2 ?e ?l)) ?l) :rewrite-rule) )) + + +;;;;;;;;;;;;;;;;;;; +;; test +(declare-fun iscons1 (list) Bool) +(assert (= (iscons1 nil1) false)) +(assert (= (iscons1 nil2) false)) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (iscons1 (cons1 ?e ?l)) true))) :pattern ((cons1 ?e ?l)) ) :rewrite-rule) )) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (iscons1 (cons2 ?e ?l)) false))) :pattern ((cons2 ?e ?l)) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons1 ?l) (= ?l (cons1 (proj11 ?l) (proj12 ?l))))) :pattern ((proj11 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons1 ?l) (= ?l (cons1 (proj11 ?l) (proj12 ?l))))) :pattern ((proj12 ?l)) ) :rewrite-rule) )) + + +(declare-fun iscons2 (list) Bool) +(assert (= (iscons2 nil1) false)) +(assert (= (iscons2 nil2) false)) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (iscons2 (cons1 ?e ?l)) false))) :pattern ((cons1 ?e ?l)) ) :rewrite-rule) )) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (iscons2 (cons2 ?e ?l)) true))) :pattern ((cons2 ?e ?l)) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons2 ?l) (= ?l (cons2 (proj21 ?l) (proj22 ?l))))) :pattern ((proj21 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons2 ?l) (= ?l (cons2 (proj21 ?l) (proj22 ?l))))) :pattern ((proj22 ?l)) ) :rewrite-rule) )) + + +(declare-fun isnil1 (list) Bool) +(assert (= (isnil1 nil1) true)) +(assert (= (isnil1 nil2) false)) +(assert (forall ((?e elt) (?l list)) + (! (= (isnil1 (cons1 ?e ?l)) false) :rewrite-rule) )) +(assert (forall ((?e elt) (?l list)) + (! (= (isnil1 (cons2 ?e ?l)) false) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (=> true (=> (isnil1 ?l) (= ?l nil1))) :rewrite-rule) )) + +(declare-fun isnil2 (list) Bool) +(assert (= (isnil2 nil1) false)) +(assert (= (isnil2 nil2) true)) +(assert (forall ((?e elt) (?l list)) + (! (= (isnil2 (cons1 ?e ?l)) false) :rewrite-rule) )) +(assert (forall ((?e elt) (?l list)) + (! (= (isnil2 (cons2 ?e ?l)) false) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (=> true (=> (isnil2 ?l) (= ?l nil2))) :rewrite-rule) )) + +;; distinct +(assert (forall ((?l list)) + (! (=> (isnil1 ?l) (and (not (isnil2 ?l)) (not (iscons1 ?l)) (not (iscons2 ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (isnil2 ?l) (and (not (isnil1 ?l)) (not (iscons1 ?l)) (not (iscons2 ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (iscons1 ?l) (and (not (isnil1 ?l)) (not (isnil2 ?l)) (not (iscons2 ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (iscons2 ?l) (and (not (isnil1 ?l)) (not (isnil2 ?l)) (not (iscons1 ?l))) ) :rewrite-rule) )) + + +;;;;;;;;;;;;;;;;;;; +;; case-split +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj11 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj12 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj21 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj22 ?l)) ) :rewrite-rule) )) + +;;;;;;;;;;;;;;;;;;; +;; finite case-split +(assert (forall ((?l list)) + (! (=> (and (not (iscons1 ?l)) (not (iscons2 ?l))) (or (isnil1 ?l) (isnil2 ?l))) :rewrite-rule) )) + + + +;;;;; goal + +(declare-fun e () elt) +(declare-fun l1 () list) +(declare-fun l2 () list) + + + (assert (not (=> (iscons2 l1) (=> (= (proj22 l1) (proj22 l2)) (= l1 (cons2 (proj21 l1) (proj22 l2))))))) + +;;(assert (= (cons1 l1 l2) (cons2 l1 l2))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/datatypes3.smt2 b/test/regress/regress1/rewriterules/datatypes3.smt2 new file mode 100644 index 000000000..1ec5dcbc4 --- /dev/null +++ b/test/regress/regress1/rewriterules/datatypes3.smt2 @@ -0,0 +1,137 @@ +;; try to solve datatypes with rewriterules +(set-logic AUFLIA) +(set-info :status unsat) + +;; lists 2 nil +(declare-sort elt 0) ;; we suppose that elt is infinite +(declare-sort list 0) + +(declare-fun nil1 () list) +(declare-fun nil2 () list) +(declare-fun cons1 (elt list) list) +(declare-fun cons2 (elt list) list) + +;;;;;;;;;;;;;;;;;;;; +;; injective + +(declare-fun inj11 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj11 (cons1 ?e ?l)) ?e))) :pattern ((cons1 ?e ?l)) ) :rewrite-rule) )) + +(declare-fun inj12 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj12 (cons1 ?e ?l)) ?l))) :pattern ((cons1 ?e ?l)) ) :rewrite-rule) )) + +(declare-fun inj21 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj21 (cons2 ?e ?l)) ?e))) :pattern ((cons2 ?e ?l)) ) :rewrite-rule) )) + +(declare-fun inj22 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj22 (cons2 ?e ?l)) ?l))) :pattern ((cons2 ?e ?l)) ) :rewrite-rule) )) + + +;;;;;;;;;;;;;;;;;;;; +;; projection + +(declare-fun proj11 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (= (proj11 (cons1 ?e ?l)) ?e) :rewrite-rule) )) + +(declare-fun proj12 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (= (proj12 (cons1 ?e ?l)) ?l) :rewrite-rule) )) + +(assert (= (proj11 nil1) nil1)) +(assert (= (proj12 nil1) nil1)) +(assert (= (proj11 nil2) nil2)) +(assert (= (proj12 nil2) nil2)) + +(declare-fun proj21 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (= (proj21 (cons2 ?e ?l)) ?e) :rewrite-rule) )) + +(declare-fun proj22 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (= (proj22 (cons2 ?e ?l)) ?l) :rewrite-rule) )) + +(assert (= (proj21 nil1) nil1)) +(assert (= (proj22 nil1) nil1)) +(assert (= (proj21 nil2) nil2)) +(assert (= (proj22 nil2) nil2)) + + +;;;;;;;;;;;;;;;;;;; +;; test +(declare-fun iscons1 (list) Bool) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (iscons1 (cons1 ?e ?l)) true))) :pattern ((cons1 ?e ?l)) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons1 ?l) (= ?l (cons1 (proj11 ?l) (proj12 ?l))))) :pattern ((proj11 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons1 ?l) (= ?l (cons1 (proj11 ?l) (proj12 ?l))))) :pattern ((proj12 ?l)) ) :rewrite-rule) )) + + +(declare-fun iscons2 (list) Bool) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (iscons2 (cons2 ?e ?l)) true))) :pattern ((cons2 ?e ?l)) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons2 ?l) (= ?l (cons2 (proj21 ?l) (proj22 ?l))))) :pattern ((proj21 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons2 ?l) (= ?l (cons2 (proj21 ?l) (proj22 ?l))))) :pattern ((proj22 ?l)) ) :rewrite-rule) )) + + +(declare-fun isnil1 (list) Bool) +(assert (= (isnil1 nil1) true)) + +(declare-fun isnil2 (list) Bool) +(assert (= (isnil2 nil2) true)) + +;; distinct +(assert (forall ((?l list)) + (! (=> (isnil1 ?l) (and (not (isnil2 ?l)) (not (iscons1 ?l)) (not (iscons2 ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (isnil2 ?l) (and (not (isnil1 ?l)) (not (iscons1 ?l)) (not (iscons2 ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (iscons1 ?l) (and (not (isnil1 ?l)) (not (isnil2 ?l)) (not (iscons2 ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (iscons2 ?l) (and (not (isnil1 ?l)) (not (isnil2 ?l)) (not (iscons1 ?l))) ) :rewrite-rule) )) + + +;;;;;;;;;;;;;;;;;;; +;; case-split +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj11 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj12 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj21 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons1 ?l) (iscons2 ?l))) :pattern ((proj22 ?l)) ) :rewrite-rule) )) + +;;;;;;;;;;;;;;;;;;; +;; finite case-split +(assert (forall ((?l list)) + (! (=> (and (not (iscons1 ?l)) (not (iscons2 ?l))) (or (isnil1 ?l) (isnil2 ?l))) :rewrite-rule) )) + + + +;;;;; goal + +(declare-fun e () elt) +(declare-fun l1 () list) +(declare-fun l2 () list) + + +;; (assert (not (=> (iscons2 l1) (=> (= (proj22 l1) (proj22 l2)) (= l1 (cons2 (proj21 l1) (proj22 l2))))))) + +(assert (= (cons1 l1 l2) (cons2 l1 l2))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/datatypes_clark_quantification.smt2 b/test/regress/regress1/rewriterules/datatypes_clark_quantification.smt2 new file mode 100644 index 000000000..6e22816d7 --- /dev/null +++ b/test/regress/regress1/rewriterules/datatypes_clark_quantification.smt2 @@ -0,0 +1,264 @@ +(set-logic AUFLIRA) + +;; DATATYPE +;; nat = succ(pred : nat) | zero, +;; list = cons(car : tree, cdr : list) | null, +;; tree = node(children : list) | leaf(data : nat) +;; END; + +;;;;;;;;;;; +;; nat ;; +;;;;;;;;;;; +(declare-sort nat 0) +(declare-fun zero () nat) +(declare-fun succ (nat) nat) + +;;;;;;;;;;;;;;;; +;; injective + +(declare-fun inj1 (nat) nat) +(assert (forall ((?x1 nat)) + (! (= (inj1 (succ ?x1)) ?x1) :pattern ((succ ?x1)) ) )) + + +;;;;;;;;;;;;;;;;;;;; +;; projection + +(declare-fun pred (nat) nat) +(assert (forall ((?x1 nat)) + (! (= (pred (succ ?x1)) ?x1) :pattern ((pred (succ ?x1))) ) )) + +(assert (= (pred zero) zero)) + +;;;;;;;;;;;;;;;;;;; +;; test +(declare-fun is_succ (nat) Bool) +(assert (= (is_succ zero) false)) +(assert (forall ((?x1 nat)) + (! (= (is_succ (succ ?x1)) true) :pattern ((succ ?x1)) ) )) + +(assert (forall ((?x1 nat)) + (! (=> (is_succ ?x1) (= ?x1 (succ (pred ?x1)))) :pattern ((is_succ ?x1) (pred ?x1)) ) )) + +(declare-fun is_zero (nat) Bool) +(assert (= (is_zero zero) true)) +(assert (forall ((?x1 nat)) + (! (=> (is_zero ?x1) (= ?x1 zero)) :pattern ((is_zero ?x1)) ) )) + +;;; directrr +(assert (forall ((?x1 nat)) + (! (= (is_succ (succ ?x1)) true) :pattern ((is_succ (succ ?x1))) ) )) +(assert (forall ((?x1 nat)) + (! (= (is_zero (succ ?x1)) false) :pattern ((is_zero (succ ?x1))) ))) + + +;;;;;;;;;;;;;;;;;;;; +;; distinct +(assert (forall ((?x1 nat)) + (! (=> (is_zero ?x1) (not (is_succ ?x1)) ) :pattern ((is_zero ?x1)) ) )) +(assert (forall ((?x1 nat)) + (! (=> (is_succ ?x1) (not (is_zero ?x1)) ) :pattern ((is_succ ?x1)) ) )) +(assert (forall ((?x1 nat)) + (! (=> (not (is_zero ?x1)) (is_succ ?x1) ) :pattern ((is_zero ?x1)) ) )) +(assert (forall ((?x1 nat)) + (! (=> (not (is_succ ?x1)) (is_zero ?x1) ) :pattern ((is_succ ?x1)) ) )) + +;;;;;;;;;;;;;;;;;;; +;; case-split +(assert (forall ((?x1 nat)) + (! (or (is_zero ?x1) (is_succ ?x1)) :pattern ((pred ?x1)) ) )) + +;;;;;;;;;;;;;;;;;;; +;; non-cyclic +(declare-fun size_nat (nat) Real) +(assert (forall ((?x1 nat)) + (! (> (size_nat (succ ?x1)) (size_nat ?x1)) :pattern ((succ ?x1)) ) )) + + + +;;;;;;;;;;;;;;;;;;;;; +;; list and tree + +(declare-sort list 0) +(declare-sort tree 0) + +;;;;;;;;;;; +;; list ;; +;;;;;;;;;;; + +(declare-fun null () list) +(declare-fun cons (tree list) list) + +(declare-fun node (list) tree) +(declare-fun leaf (nat) tree) + +;;;;;;;;;;;;;;;; +;; injective + +(declare-fun inj2 (list) tree) +(assert (forall ((?x1 tree) (?x2 list)) + (! (= (inj2 (cons ?x1 ?x2)) ?x1) :pattern ((cons ?x1 ?x2)) ) )) + +(declare-fun inj3 (list) list) +(assert (forall ((?x1 tree) (?x2 list)) + (! (= (inj3 (cons ?x1 ?x2)) ?x2) :pattern ((cons ?x1 ?x2)) ) )) + + +;;;;;;;;;;;;;;;;;;;; +;; projection + +(declare-fun car (list) tree) +(assert (forall ((?x1 tree) (?x2 list)) + (! (= (car (cons ?x1 ?x2)) ?x1) :pattern ((car (cons ?x1 ?x2))) ) )) + +(assert (= (car null) (node null))) + +(declare-fun cdr (list) list) +(assert (forall ((?x1 tree) (?x2 list)) + (! (= (cdr (cons ?x1 ?x2)) ?x2) :pattern ((cdr (cons ?x1 ?x2))) ) )) + +(assert (= (cdr null) null)) + +;;;;;;;;;;;;;;;;;;; +;; test +(declare-fun is_cons (list) Bool) +(assert (= (is_cons null) false)) +(assert (forall ((?x1 tree) (?x2 list)) + (! (= (is_cons (cons ?x1 ?x2)) true) :pattern ((cons ?x1 ?x2)) ) )) + +(assert (forall ((?x1 list)) + (! (=> (is_cons ?x1) (= ?x1 (cons (car ?x1) (cdr ?x1)))) :pattern ((is_cons ?x1)(car ?x1)) ) )) +(assert (forall ((?x1 list)) + (! (=> (is_cons ?x1) (= ?x1 (cons (car ?x1) (cdr ?x1)))) :pattern ((is_cons ?x1)(cdr ?x1)) ) )) + +(declare-fun is_null (list) Bool) +(assert (= (is_null null) true)) + +(assert (forall ((?x1 list)) + (! (=> (is_null ?x1) (= (car ?x1) (node null))) :pattern ((is_null ?x1)(car ?x1)) ) )) +(assert (forall ((?x1 list)) + (! (=> (is_null ?x1) (= (cdr ?x1) null)) :pattern ((is_null ?x1)(cdr ?x1)) ) )) + +(assert (forall ((?x1 list)) + (! (=> (is_null ?x1) (= ?x1 null)) :pattern ((is_null ?x1)) ) )) + +;;; directrr +(assert (forall ((?x1 tree) (?x2 list)) + (! (= (is_cons (cons ?x1 ?x2)) true) :pattern ((is_cons (cons ?x1 ?x2))) ) )) +(assert (forall ((?x1 tree) (?x2 list)) + (! (= (is_null (cons ?x1 ?x2)) false) :pattern ((is_null (cons ?x1 ?x2))) ) )) + + + +;;;;;;;;;;;;;;;;;;;; +;; distinct +(assert (forall ((?x1 list)) + (! (=> (is_null ?x1) (not (is_cons ?x1)) ) :pattern ((is_null ?x1)) ) )) +(assert (forall ((?x1 list)) + (! (=> (is_cons ?x1) (not (is_null ?x1)) ) :pattern ((is_cons ?x1)) ) )) +(assert (forall ((?x1 list)) + (! (=> (not (is_null ?x1)) (is_cons ?x1) ) :pattern ((is_null ?x1)) ) )) +(assert (forall ((?x1 list)) + (! (=> (not (is_cons ?x1)) (is_null ?x1) ) :pattern ((is_cons ?x1)) ) )) + +;;;;;;;;;;;;;;;;;;; +;; case-split +(assert (forall ((?x1 list)) + (! (or (is_null ?x1) (is_cons ?x1)) :pattern ((car ?x1)) ) )) +(assert (forall ((?x1 list)) + (! (or (is_null ?x1) (is_cons ?x1)) :pattern ((cdr ?x1)) ) )) + +;;;;;;;;;;;;;;; +;; tree + +;;;;;;;;;;;;;;;; +;; injective + +(declare-fun inj4 (tree) list) +(assert (forall ((?x1 list)) + (! (= (inj4 (node ?x1)) ?x1) :pattern ((node ?x1)) ) )) + +(declare-fun inj5 (tree) nat) +(assert (forall ((?x1 nat)) + (! (= (inj5 (leaf ?x1)) ?x1) :pattern ((leaf ?x1)) ) )) + + +;;;;;;;;;;;;;;;;;;;; +;; projection + +(declare-fun children (tree) list) +(assert (forall ((?x1 list)) + (! (= (children (node ?x1)) ?x1) :pattern ((children (node ?x1))) ) )) +(assert (forall ((?x1 nat)) + (! (= (children (leaf ?x1)) null) :pattern ((children (leaf ?x1))) ) )) + + +(declare-fun data (tree) nat) +(assert (forall ((?x1 nat)) + (! (= (data (leaf ?x1)) ?x1) :pattern ((data (leaf ?x1))) ) )) +(assert (forall ((?x1 list)) + (! (= (data (node ?x1)) zero) :pattern ((data (node ?x1))) ) )) + +;;;;;;;;;;;;;;;;;;; +;; test +(declare-fun is_node (tree) Bool) +(assert (forall ((?x1 list)) + (! (= (is_node (node ?x1)) true) :pattern ((node ?x1)) ) )) + +(assert (forall ((?x1 tree)) + (! (=> (is_node ?x1) (= ?x1 (node (children ?x1)))) :pattern ((is_node ?x1)(children ?x1)) ) )) + +(assert (forall ((?x1 tree)) + (! (=> (is_node ?x1) (= (data ?x1) zero)) :pattern ((is_node ?x1)(data ?x1)) ) )) + + +(declare-fun is_leaf (tree) Bool) +(assert (forall ((?x1 nat)) + (! (=> true (= (is_leaf (leaf ?x1)) true)) :pattern ((leaf ?x1)) ) )) + +(assert (forall ((?x1 tree)) + (! (=> (is_leaf ?x1) (= ?x1 (leaf (data ?x1)))) :pattern ((is_leaf ?x1)(data ?x1)) ) )) +(assert (forall ((?x1 tree)) + (! (=> (is_leaf ?x1) (= (children ?x1) null)) :pattern ((is_leaf ?x1)(children ?x1)) ) )) + +;;; directrr +(assert (forall ((?x1 list)) + (! (= (is_node (node ?x1)) true) :pattern ((is_node (node ?x1))) ) )) +(assert (forall ((?x1 list)) + (! (= (is_leaf (node ?x1)) false) :pattern ((is_leaf (node ?x1))) ) )) +(assert (forall ((?x1 nat)) + (! (= (is_leaf (leaf ?x1)) true) :pattern (is_leaf (leaf ?x1)) ) )) +(assert (forall ((?x1 nat)) + (! (= (is_node (leaf ?x1)) false) :pattern ((is_node (leaf ?x1))) ) )) + + +;;;;;;;;;;;;;;;;;;;; +;; distinct +(assert (forall ((?x1 tree)) + (! (=> (is_node ?x1) (not (is_leaf ?x1)) ) :pattern ((is_node ?x1)) ) )) +(assert (forall ((?x1 tree)) + (! (=> (is_leaf ?x1) (not (is_node ?x1)) ) :pattern ((is_leaf ?x1)) ) )) +(assert (forall ((?x1 tree)) + (! (=> (not (is_node ?x1)) (is_leaf ?x1) ) :pattern ((is_node ?x1)) ) )) +(assert (forall ((?x1 tree)) + (! (=> (not (is_leaf ?x1)) (is_node ?x1) ) :pattern ((is_leaf ?x1)) ) )) + +;;;;;;;;;;;;;;;;;;; +;; case-split +(assert (forall ((?x1 tree)) + (! (or (is_node ?x1) (is_leaf ?x1)) :pattern ((children ?x1)) ) )) + +(assert (forall ((?x1 tree)) + (! (or (is_node ?x1) (is_leaf ?x1)) :pattern ((data ?x1)) ) )) + + +;;;;;;;;;;;;;;;;;; +;; non-cyclic +(declare-fun size_list (list) Real) +(declare-fun size_tree (tree) Real) +(assert (forall ((?x1 tree) (?x2 list)) + (! (and (> (size_list (cons ?x1 ?x2)) (size_tree ?x1)) (> (size_list (cons ?x1 ?x2)) (size_list ?x2))) :pattern ((cons ?x1 ?x2)) ) )) +(assert (forall ((?x1 list)) + (! (> (size_tree (node ?x1)) (size_list ?x1)) :pattern ((node ?x1)) ) )) +(assert (forall ((?x1 nat)) + (! (> (size_tree (leaf ?x1)) (size_nat ?x1)) :pattern ((leaf ?x1)) ) )) diff --git a/test/regress/regress1/rewriterules/datatypes_sat.smt2 b/test/regress/regress1/rewriterules/datatypes_sat.smt2 new file mode 100644 index 000000000..92576f976 --- /dev/null +++ b/test/regress/regress1/rewriterules/datatypes_sat.smt2 @@ -0,0 +1,101 @@ +;; try to solve datatypes with rewriterules +(set-logic AUFLIA) +(set-info :status sat) + +;; lists 2 nil +(declare-sort elt 0) ;; we suppose that elt is infinite +(declare-sort list 0) + +(declare-fun nil1 () list) +(declare-fun nil2 () list) +(declare-fun cons (elt list) list) + +;;;;;;;;;;;;;;;;;;;; +;; injective + +(declare-fun inj1 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj1 (cons ?e ?l)) ?e))) :pattern ((cons ?e ?l)) ) :rewrite-rule) )) + +(declare-fun inj2 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (inj2 (cons ?e ?l)) ?l))) :pattern ((cons ?e ?l)) ) :rewrite-rule) )) + +;;;;;;;;;;;;;;;;;;;; +;; projection + +(declare-fun proj1 (list) elt) +(assert (forall ((?e elt) (?l list)) + (! (= (proj1 (cons ?e ?l)) ?e) :rewrite-rule) )) + +(declare-fun proj2 (list) list) +(assert (forall ((?e elt) (?l list)) + (! (= (proj2 (cons ?e ?l)) ?l) :rewrite-rule) )) + +;;;;;;;;;;;;;;;;;;; +;; test +(declare-fun iscons (list) Bool) +(assert (= (iscons nil1) false)) +(assert (= (iscons nil2) false)) +(assert (forall ((?e elt) (?l list)) + (! (! (=> true (=> true (= (iscons (cons ?e ?l)) true))) :pattern ((cons ?e ?l)) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons ?l) (= ?l (cons (proj1 ?l) (proj2 ?l))))) :pattern ((proj1 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (=> (iscons ?l) (= ?l (cons (proj1 ?l) (proj2 ?l))))) :pattern ((proj2 ?l)) ) :rewrite-rule) )) + + +(declare-fun isnil1 (list) Bool) +(assert (= (isnil1 nil1) true)) +(assert (= (isnil1 nil2) false)) +(assert (forall ((?e elt) (?l list)) + (! (= (isnil1 (cons ?e ?l)) false) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (=> true (=> (isnil1 ?l) (= ?l nil1))) :rewrite-rule) )) + +(declare-fun isnil2 (list) Bool) +(assert (= (isnil2 nil1) false)) +(assert (= (isnil2 nil2) true)) +(assert (forall ((?e elt) (?l list)) + (! (= (isnil2 (cons ?e ?l)) false) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (=> true (=> (isnil2 ?l) (= ?l nil2))) :rewrite-rule) )) + +;; distinct +(assert (forall ((?l list)) + (! (=> (isnil1 ?l) (and (not (isnil2 ?l)) (not (iscons ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (isnil2 ?l) (and (not (isnil1 ?l)) (not (iscons ?l))) ) :rewrite-rule) )) + +(assert (forall ((?l list)) + (! (=> (iscons ?l) (and (not (isnil1 ?l)) (not (isnil2 ?l))) ) :rewrite-rule) )) + + +;;;;;;;;;;;;;;;;;;; +;; case-split +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons ?l))) :pattern ((proj1 ?l)) ) :rewrite-rule) )) +(assert (forall ((?l list)) + (! (! (=> true (or (isnil1 ?l) (isnil2 ?l) (iscons ?l))) :pattern ((proj2 ?l)) ) :rewrite-rule) )) + +;;;;;;;;;;;;;;;;;;; +;; finite case-split +(assert (forall ((?l list)) + (! (=> (not (iscons ?l)) (or (isnil1 ?l) (isnil2 ?l))) :rewrite-rule) )) + + + +;;;;; goal + +(declare-fun e () elt) +(declare-fun l1 () list) +(declare-fun l2 () list) + + +(assert (not (=> (iscons l1) (=> (= (proj2 l1) (proj2 l2)) (= l1 (cons (proj1 l2) (proj2 l2))))))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen.smt2 b/test/regress/regress1/rewriterules/length_gen.smt2 new file mode 100644 index 000000000..dda478357 --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (! (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)) :rewrite-rule))) + +(assert (forall ((?n Int) (?l list)) (! (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))) :rewrite-rule))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 42 nil)) 42))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_010.smt2 b/test/regress/regress1/rewriterules/length_gen_010.smt2 new file mode 100644 index 000000000..052f5905b --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_010.smt2 @@ -0,0 +1,36 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +;; (assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(assert-rewrite ((?e Int) (?l list)) () () (length (cons ?e ?l)) (+ 1 (length ?l))) + +(declare-fun gen_cons (Int list) list) + +(assert-rewrite ((?n Int) (?l list)) () (= ?n 0) (gen_cons ?n ?l) (?l)) + +(assert-rewrite ((?n Int) (?l list)) () (> ?n 0) (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 10 nil)) 10))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_010_lemma.smt2 b/test/regress/regress1/rewriterules/length_gen_010_lemma.smt2 new file mode 100644 index 000000000..02bc877fc --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_010_lemma.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (= (length (cons ?e ?l)) (+ 1 (length ?l))))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)))) + +(assert (forall ((?n Int) (?l list)) (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 10 nil)) 10))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_020.smt2 b/test/regress/regress1/rewriterules/length_gen_020.smt2 new file mode 100644 index 000000000..8e0021175 --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_020.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (! (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)) :rewrite-rule))) + +(assert (forall ((?n Int) (?l list)) (! (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))) :rewrite-rule))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 20 nil)) 20))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_020_sat.smt2 b/test/regress/regress1/rewriterules/length_gen_020_sat.smt2 new file mode 100644 index 000000000..cc75eb85a --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_020_sat.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status sat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (! (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)) :rewrite-rule))) + +(assert (forall ((?n Int) (?l list)) (! (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))) :rewrite-rule))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 20 nil)) 200))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_040.smt2 b/test/regress/regress1/rewriterules/length_gen_040.smt2 new file mode 100644 index 000000000..687422223 --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_040.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (! (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)) :rewrite-rule))) + +(assert (forall ((?n Int) (?l list)) (! (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))) :rewrite-rule))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 40 nil)) 40))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_040_lemma.smt2 b/test/regress/regress1/rewriterules/length_gen_040_lemma.smt2 new file mode 100644 index 000000000..293ea147b --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_040_lemma.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (= (length (cons ?e ?l)) (+ 1 (length ?l))))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)))) + +(assert (forall ((?n Int) (?l list)) (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 40 nil)) 40))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_040_lemma_trigger.smt2 b/test/regress/regress1/rewriterules/length_gen_040_lemma_trigger.smt2 new file mode 100644 index 000000000..69f9f97be --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_040_lemma_trigger.smt2 @@ -0,0 +1,35 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (!(= (length (cons ?e ?l)) (+ 1 (length ?l))) :pattern ((length (cons ?e ?l))) ))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (! (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)) :pattern ((gen_cons ?n ?l)) ))) + +(assert (forall ((?n Int) (?l list)) (! (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))) + :pattern ((gen_cons ?n ?l)) ))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 40 nil)) 40))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_080.smt2 b/test/regress/regress1/rewriterules/length_gen_080.smt2 new file mode 100644 index 000000000..061042be3 --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_080.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (! (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)) :rewrite-rule))) + +(assert (forall ((?n Int) (?l list)) (! (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))) :rewrite-rule))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 80 nil)) 80))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_160_lemma.smt2 b/test/regress/regress1/rewriterules/length_gen_160_lemma.smt2 new file mode 100644 index 000000000..28b58183e --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_160_lemma.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (= (length (cons ?e ?l)) (+ 1 (length ?l))))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)))) + +(assert (forall ((?n Int) (?l list)) (=> (> ?n 0) (= (gen_cons ?n ?l) + (gen_cons (- ?n 1) (cons 1 ?l)))))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 160 nil)) 160))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_gen_inv_160.smt2 b/test/regress/regress1/rewriterules/length_gen_inv_160.smt2 new file mode 100644 index 000000000..9c2a5c307 --- /dev/null +++ b/test/regress/regress1/rewriterules/length_gen_inv_160.smt2 @@ -0,0 +1,34 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(declare-fun gen_cons (Int list) list) + +(assert (forall ((?n Int) (?l list)) (! (=> (= ?n 0) (= (gen_cons ?n ?l) ?l)) :rewrite-rule))) + +(assert (forall ((?n Int) (?l list)) (! (=> (> ?n 0) (= (gen_cons ?n ?l) + (cons 1 (gen_cons (- ?n 1) ?l)))) :rewrite-rule))) + +(declare-fun n () Int) + +(assert (not (= (length (gen_cons 160 nil)) 160))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_trick3.smt2 b/test/regress/regress1/rewriterules/length_trick3.smt2 new file mode 100644 index 000000000..f6899541b --- /dev/null +++ b/test/regress/regress1/rewriterules/length_trick3.smt2 @@ -0,0 +1,36 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) +;; don't use arith +(declare-sort mynat 0) +(declare-fun zero () mynat) +(declare-fun succ (mynat) mynat) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) mynat) + +(assert (= (length nil) zero)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (succ (length ?l))) :rewrite-rule))) + +(declare-fun ten_one_cons (list) list) + +(assert (forall ((?l list)) (! (= (ten_one_cons ?l) + (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 ?l) ))))))))) + ) :rewrite-rule))) + +(assert (not (= (length (ten_one_cons nil)) + (succ(succ(succ(succ(succ(succ(succ(succ(succ(succ zero))))))))))))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/length_trick3_int.smt2 b/test/regress/regress1/rewriterules/length_trick3_int.smt2 new file mode 100644 index 000000000..d58bf55fe --- /dev/null +++ b/test/regress/regress1/rewriterules/length_trick3_int.smt2 @@ -0,0 +1,44 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) + + +;;define length +(declare-fun length (list) Int) + +(assert (= (length nil) 0)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (+ 1 (length ?l))) :rewrite-rule))) + +(declare-fun ten_one_cons (list) list) + +(assert (forall ((?l list)) (! (= (ten_one_cons ?l) + (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 ?l) ))))))))) + ) :rewrite-rule))) + +(assert (not (= (length (ten_one_cons nil)) + 10))) + +(check-sat) + +(declare-fun ten_one_ten (list) list) + +(assert (forall ((?l list)) (! (= (ten_one_ten ?l) + (ten_one_cons (ten_one_cons (ten_one_cons (ten_one_cons (ten_one_cons (ten_one_cons (ten_one_cons (ten_one_cons (ten_one_cons (ten_one_cons ?l) ))))))))) + ) :rewrite-rule))) + +(declare-fun two_one_ten (list) list) + +(assert (forall ((?l list)) (! (= (two_one_ten ?l) + (ten_one_cons (ten_one_cons ?l)) + ) :rewrite-rule))) + +(exit) diff --git a/test/regress/regress1/rewriterules/set_A_new_fast_tableau-base.smt2 b/test/regress/regress1/rewriterules/set_A_new_fast_tableau-base.smt2 new file mode 100644 index 000000000..9bd49f714 --- /dev/null +++ b/test/regress/regress1/rewriterules/set_A_new_fast_tableau-base.smt2 @@ -0,0 +1,126 @@ +;; A new fast tableau-base ... Domenico Cantone et Calogero G.Zarba +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort elt 0) +(declare-sort set 0) + +(declare-fun in (elt set) Bool) + +;;;;;;;;;;;;;;;;;;;; +;; inter + +(declare-fun inter (set set) set) +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) () () + ((in ?s (inter ?t1 ?t2))) (and (in ?s ?t1) (in ?s ?t2))) + + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((not (in ?s ?t1))) (not (in ?s (inter ?t1 ?t2))) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((not (in ?s ?t2))) (not (in ?s (inter ?t1 ?t2))) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (inter ?t1 ?t2))) (in ?s ?t1)) (not (in ?s ?t2)) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (inter ?t1 ?t2))) (in ?s ?t2)) (not (in ?s ?t1))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((in ?s ?t1) (in ?s ?t2)) (in ?s (inter ?t1 ?t2)) ) + +;;;;;;;;;;;;;;;;; +;; union + +(declare-fun union (set set) set) +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (union ?t1 ?t2)))) (and (not (in ?s ?t1)) (not (in ?s ?t2)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((union ?t1 ?t2))) () ((in ?s ?t1)) (in ?s (union ?t1 ?t2))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((union ?t1 ?t2))) () ((in ?s ?t2)) (in ?s (union ?t1 ?t2))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (union ?t1 ?t2)) (not (in ?s ?t1))) (in ?s ?t2)) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (union ?t1 ?t2)) (not (in ?s ?t2))) (in ?s ?t1)) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((union ?t1 ?t2))) () ((not (in ?s ?t1)) (not (in ?s ?t2))) (not (in ?s (union ?t1 ?t2)))) + +;;;;;;;;;;;;;;;;;;;; +;; diff + +(declare-fun diff (set set) set) +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (diff ?t1 ?t2))) (and (in ?s ?t1) (not (in ?s ?t2)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((diff ?t1 ?t2))) () ((not (in ?s ?t1))) (not (in ?s (diff ?t1 ?t2))) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((diff ?t1 ?t2))) () ((in ?s ?t2)) (not (in ?s (diff ?t1 ?t2)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (diff ?t1 ?t2))) (in ?s ?t1)) (in ?s ?t2)) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (diff ?t1 ?t2))) (not (in ?s ?t2))) (not (in ?s ?t1))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((diff ?t1 ?t2))) () ((in ?s ?t1) (not (in ?s ?t2))) (in ?s (diff ?t1 ?t2)) ) + +;;;;;;;;;;;;;;;; +;;sing + +(declare-fun sing (elt) set) +(assert-propagation ((?s elt)) + (((sing ?s))) () () (in ?s (sing ?s)) ) + +(assert-propagation ((?s elt) (?t1 elt)) + () () ((in ?s (sing ?t1))) (= ?s ?t1)) + +(assert-propagation ((?s elt) (?t1 elt)) + () () ((not (in ?s (sing ?t1)))) (not (= ?s ?t1))) + +;;;;;;;;;;;;;;;;;;; +;; fullfiling runned at Full effort +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (union ?t1 ?t2))) (or (in ?s ?t1) (not (in ?s ?t1)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((in ?s ?t1)) (or (in ?s ?t2) (not (in ?s ?t2)))) + +(assert-propagation ((?t1 set) (?t2 set)) + () () ((not (= ?t1 ?t2))) (exists ((?e elt)) (or (and (in ?e ?t1) (not (in ?e ?t2))) (and (not (in ?e ?t1)) (in ?e ?t2))))) + +;;;;;;;;;;;;;;;;;;; +;; shortcut +(declare-fun subset (set set) Bool) +(assert-reduction ((?t1 set) (?t2 set)) + () () ((subset ?t1 ?t2)) (= (union ?t1 ?t2) ?t2)) + +(declare-fun e () elt) +(declare-fun t1 () set) +(declare-fun t2 () set) +(declare-fun t3 () set) + +;;(assert (not (=> (in e (inter (union t1 t2) (union t1 t1))) (in e (union t1 t1))))) +;;(assert (not (=> (in e (union t1 t1)) (in e t1)))) + +;; hyp +;;(assert (=> (in e (union t1 t1)) (in e t1))) + +;;(assert (not (=> (in e (inter (union t1 t2) (union t1 t1))) (in e t1)))) + +;;(assert (or (and (not (in e (union t1 (union t2 t3)))) (in e (union (union t1 t2) t3))) (and (in e (union t1 (union t2 t3))) (not (in e (union (union t1 t2) t3))))) ) +(assert (not (= (union t1 (union t2 t3)) (union (union t1 t2) t3))) ) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/set_A_new_fast_tableau-base_sat.smt2 b/test/regress/regress1/rewriterules/set_A_new_fast_tableau-base_sat.smt2 new file mode 100644 index 000000000..4d65ffac5 --- /dev/null +++ b/test/regress/regress1/rewriterules/set_A_new_fast_tableau-base_sat.smt2 @@ -0,0 +1,127 @@ +;; A new fast tableau-base ... Domenico Cantone et Calogero G.Zarba +(set-logic AUFLIA) +(set-info :status sat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort elt 0) +(declare-sort set 0) + +(declare-fun in (elt set) Bool) + + +;;;;;;;;;;;;;;;;;;;; +;; inter + +(declare-fun inter (set set) set) +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) () () + ((in ?s (inter ?t1 ?t2))) (and (in ?s ?t1) (in ?s ?t2))) + + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((not (in ?s ?t1))) (not (in ?s (inter ?t1 ?t2))) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((not (in ?s ?t2))) (not (in ?s (inter ?t1 ?t2))) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (inter ?t1 ?t2))) (in ?s ?t1)) (not (in ?s ?t2)) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (inter ?t1 ?t2))) (in ?s ?t2)) (not (in ?s ?t1))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((in ?s ?t1) (in ?s ?t2)) (in ?s (inter ?t1 ?t2)) ) + +;;;;;;;;;;;;;;;;; +;; union + +(declare-fun union (set set) set) +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (union ?t1 ?t2)))) (and (not (in ?s ?t1)) (not (in ?s ?t2)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((union ?t1 ?t2))) () ((in ?s ?t1)) (in ?s (union ?t1 ?t2))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((union ?t1 ?t2))) () ((in ?s ?t2)) (in ?s (union ?t1 ?t2))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (union ?t1 ?t2)) (not (in ?s ?t1))) (in ?s ?t2)) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (union ?t1 ?t2)) (not (in ?s ?t2))) (in ?s ?t1)) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((union ?t1 ?t2))) () ((not (in ?s ?t1)) (not (in ?s ?t2))) (not (in ?s (union ?t1 ?t2)))) + +;;;;;;;;;;;;;;;;;;;; +;; diff + +(declare-fun diff (set set) set) +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (diff ?t1 ?t2))) (and (in ?s ?t1) (not (in ?s ?t2)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((diff ?t1 ?t2))) () ((not (in ?s ?t1))) (not (in ?s (diff ?t1 ?t2))) ) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((diff ?t1 ?t2))) () ((in ?s ?t2)) (not (in ?s (diff ?t1 ?t2)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (diff ?t1 ?t2))) (in ?s ?t1)) (in ?s ?t2)) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((not (in ?s (diff ?t1 ?t2))) (not (in ?s ?t2))) (not (in ?s ?t1))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((diff ?t1 ?t2))) () ((in ?s ?t1) (not (in ?s ?t2))) (in ?s (diff ?t1 ?t2)) ) + +;;;;;;;;;;;;;;;; +;;sing + +(declare-fun sing (elt) set) +(assert-propagation ((?s elt)) + (((sing ?s))) () () (in ?s (sing ?s)) ) + +(assert-propagation ((?s elt) (?t1 elt)) + () () ((in ?s (sing ?t1))) (= ?s ?t1)) + +(assert-propagation ((?s elt) (?t1 elt)) + () () ((not (in ?s (sing ?t1)))) (not (= ?s ?t1))) + +;;;;;;;;;;;;;;;;;;; +;; fullfiling runned at Full effort +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + () () ((in ?s (union ?t1 ?t2))) (or (in ?s ?t1) (not (in ?s ?t1)))) + +(assert-propagation ((?s elt) (?t1 set) (?t2 set)) + (((inter ?t1 ?t2))) () ((in ?s ?t1)) (or (in ?s ?t2) (not (in ?s ?t2)))) + +(assert-propagation ((?t1 set) (?t2 set)) + () () ((not (= ?t1 ?t2))) (exists ((?e elt)) (or (and (in ?e ?t1) (not (in ?e ?t2))) (and (not (in ?e ?t1)) (in ?e ?t2))))) + +;;;;;;;;;;;;;;;;;;; +;; shortcut +(declare-fun subset (set set) Bool) +(assert-reduction ((?t1 set) (?t2 set)) + () () ((subset ?t1 ?t2)) (= (union ?t1 ?t2) ?t2)) + +(declare-fun e () elt) +(declare-fun t1 () set) +(declare-fun t2 () set) +(declare-fun t3 () set) + +;;(assert (not (=> (in e (inter (union t1 t2) (union t1 t1))) (in e (union t1 t1))))) +;;(assert (not (=> (in e (union t1 t1)) (in e t1)))) + +;; hyp +;;(assert (=> (in e (union t1 t1)) (in e t1))) + +;;(assert (not (=> (in e (inter (union t1 t2) (union t1 t1))) (in e t1)))) + +(assert (or (and (not (in e (union t1 (union t2 t3)))) (in e (union (union t1 t2) t3))) (and (in e (union t1 (union t2 t3))) (not (in e (union (union t2 t2) t3))))) ) + + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/test_guards.smt2 b/test/regress/regress1/rewriterules/test_guards.smt2 new file mode 100644 index 000000000..98c845fb5 --- /dev/null +++ b/test/regress/regress1/rewriterules/test_guards.smt2 @@ -0,0 +1,45 @@ +;; Same than length.smt2 but the nil case is not a rewrite rule +;; So here the rewrite rules have no guards length + +(set-logic AUFLIA) +(set-info :status unsat) + +;; don't use a datatypes for currently focusing in uf +(declare-sort list 0) +;; don't use arith +(declare-sort mynat 0) +(declare-fun zero () mynat) +(declare-fun succ (mynat) mynat) + +(declare-fun cons (Int list) list) +(declare-fun nil () list) +(declare-fun p (list) Bool) + + +;;define length +(declare-fun length (list) mynat) + +(assert (= (length nil) zero)) + +(assert (forall ((?e Int) (?l list)) (! (= (length (cons ?e ?l)) (succ (length ?l))) :rewrite-rule))) + +(declare-fun ten_one_cons (list) list) + +(assert (forall ((?l list)) (! (=> (p ?l) (= (ten_one_cons ?l) + (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 ?l) ))))))))) + )) :rewrite-rule))) + +(declare-fun a () Bool) +(declare-fun b () Bool) +(declare-fun c () Bool) + +(assert (=> a (p nil)) ) +(assert (=> b (p nil)) ) +(assert (or a b)) + +(assert (not (= (length (ten_one_cons nil)) + (succ(succ(succ(succ(succ(succ(succ(succ(succ(succ zero))))))))))))) + +(check-sat) + +(exit) diff --git a/test/regress/regress1/rewriterules/why3_vstte10_max_sum_harness2.smt2 b/test/regress/regress1/rewriterules/why3_vstte10_max_sum_harness2.smt2 new file mode 100644 index 000000000..4d39e12bb --- /dev/null +++ b/test/regress/regress1/rewriterules/why3_vstte10_max_sum_harness2.smt2 @@ -0,0 +1,492 @@ +;;; From a verification condition generated by why3. The original program +;; can be found at http://toccata.lri.fr/gallery/vstte10_max_sum.en.html . +;; The problem has been modified by doubling the size of the arrays +;; (* **) +;; VSTTE'10 competition http://www.macs.hw.ac.uk/vstte10/Competition.html **) +;; Problem 1: maximum /\ sum of an array **) + +;; Author: Jean-Christophe Filliatre (CNRS) **) +;; Tool: Why3 (see http://why3.lri.fr/) **) +;; *\) **) + +;; Particularly the assertion in the test case that the sum s = 90 + +;;; this is a prelude for CVC4 +(set-logic AUFNIRA) +;;; this is a prelude for CVC4 integer arithmetic +(declare-sort uni 0) + +(declare-sort deco 0) + +(declare-sort ty 0) + +(declare-fun sort (ty uni) deco) + +(declare-fun int () ty) + +(declare-fun real () ty) + +(declare-fun bool () ty) + +(declare-fun True () uni) + +(declare-fun False () uni) + +(declare-fun match_bool (deco deco deco) uni) + +;; match_bool_True + (assert + (forall ((a ty)) + (forall ((z uni) (z1 uni)) + (= (sort a (match_bool (sort bool True) (sort a z) (sort a z1))) (sort a z))))) + +;; match_bool_False + (assert + (forall ((a ty)) + (forall ((z uni) (z1 uni)) + (= (sort a (match_bool (sort bool False) (sort a z) (sort a z1))) (sort a + z1))))) + +(declare-fun index_bool (deco) Int) + +;; index_bool_True + (assert (= (index_bool (sort bool True)) 0)) + +;; index_bool_False + (assert (= (index_bool (sort bool False)) 1)) + +;; bool_inversion + (assert + (forall ((u uni)) + (or (= (sort bool u) (sort bool True)) (= (sort bool u) (sort bool False))))) + +(declare-fun tuple0 () ty) + +(declare-fun Tuple0 () uni) + +;; tuple0_inversion + (assert (forall ((u uni)) (= (sort tuple0 u) (sort tuple0 Tuple0)))) + +;; CompatOrderMult + (assert + (forall ((x Int) (y Int) (z Int)) + (=> (<= x y) (=> (<= 0 z) (<= (* x z) (* y z)))))) + +(declare-fun ref (ty) ty) + +(declare-fun mk_ref (deco) uni) + +(declare-fun contents (deco) uni) + +;; contents_def + (assert + (forall ((a ty)) + (forall ((u uni)) + (= (sort a (contents (sort (ref a) (mk_ref (sort a u))))) (sort a u))))) + +;; ref_inversion + (assert + (forall ((a ty)) + (forall ((u uni)) + (= (sort (ref a) u) (sort (ref a) + (mk_ref (sort a (contents (sort (ref a) u))))))))) + +(declare-fun map (ty ty) ty) + +(declare-fun get (deco deco) uni) + +(declare-fun set (deco deco deco) uni) + +;; Select_eq + (assert + (forall ((m (Array Int Int))) + (forall ((a1 Int) (a2 Int)) + (forall ((b Int)) + (! (=> (= a1 a2) (= (select (store m a1 b) a2) b)) :pattern ((select (store m a1 b) a2)) ))))) + +;; Select_eq + (assert + (forall ((a ty) (b ty)) + (forall ((m uni)) + (forall ((a1 uni) (a2 uni)) + (forall ((b1 uni)) + (! (=> (= (sort a a1) (sort a a2)) + (= (sort b + (get + (sort (map a b) (set (sort (map a b) m) (sort a a1) (sort b b1))) + (sort a a2))) (sort b b1))) :pattern ((sort b + (get + (sort (map a b) + (set (sort (map a b) m) + (sort a a1) (sort b b1))) + (sort a a2)))) )))))) + +;; Select_neq + (assert + (forall ((m (Array Int Int))) + (forall ((a1 Int) (a2 Int)) + (forall ((b Int)) + (! (=> (not (= a1 a2)) (= (select (store m a1 b) a2) (select m a2))) :pattern ((select (store m a1 b) a2)) ))))) + +;; Select_neq + (assert + (forall ((a ty) (b ty)) + (forall ((m uni)) + (forall ((a1 uni) (a2 uni)) + (forall ((b1 uni)) + (! (=> (not (= (sort a a1) (sort a a2))) + (= (sort b + (get + (sort (map a b) (set (sort (map a b) m) (sort a a1) (sort b b1))) + (sort a a2))) (sort b (get (sort (map a b) m) (sort a a2))))) :pattern ( + (sort b + (get (sort (map a b) (set (sort (map a b) m) (sort a a1) (sort b b1))) + (sort a a2)))) )))))) + +(declare-fun const1 (deco) uni) + +(declare-fun const2 (Int) (Array Int Int)) + +;; Const + (assert (forall ((b Int) (a Int)) (= (select (const2 b) a) b))) + +;; Const + (assert + (forall ((a ty) (b ty)) + (forall ((b1 uni) (a1 uni)) + (= (sort b (get (sort (map a b) (const1 (sort b b1))) (sort a a1))) + (sort b b1))))) + +(declare-sort array 1) + +(declare-fun array1 (ty) ty) + +(declare-fun mk_array (Int deco) uni) + +(declare-fun mk_array1 (Int (Array Int Int)) (array Int)) + +(declare-fun length (deco) Int) + +(declare-fun t2tb ((array Int)) uni) + +(declare-fun tb2t (deco) (array Int)) + +;; BridgeL + (assert + (forall ((i (array Int))) + (! (= (tb2t (sort (array1 int) (t2tb i))) i) :pattern ((sort (array1 int) + (t2tb i))) ))) + +;; BridgeR + (assert + (forall ((j uni)) + (! (= (sort (array1 int) (t2tb (tb2t (sort (array1 int) j)))) (sort + (array1 int) + j)) :pattern ( + (sort (array1 int) (t2tb (tb2t (sort (array1 int) j))))) ))) + +;; length_def + (assert + (forall ((u Int) (u1 (Array Int Int))) + (= (length (sort (array1 int) (t2tb (mk_array1 u u1)))) u))) + +;; length_def + (assert + (forall ((a ty)) + (forall ((u Int) (u1 uni)) + (= (length (sort (array1 a) (mk_array u (sort (map int a) u1)))) u)))) + +(declare-fun elts (deco) uni) + +(declare-fun t2tb1 ((Array Int Int)) uni) + +(declare-fun tb2t1 (deco) (Array Int Int)) + +;; BridgeL + (assert + (forall ((i (Array Int Int))) + (! (= (tb2t1 (sort (map int int) (t2tb1 i))) i) :pattern ((sort + (map int int) + (t2tb1 i))) ))) + +;; BridgeR + (assert + (forall ((j uni)) + (! (= (sort (map int int) (t2tb1 (tb2t1 (sort (map int int) j)))) (sort + (map + int + int) j)) :pattern ( + (sort (map int int) (t2tb1 (tb2t1 (sort (map int int) j))))) ))) + +;; elts_def + (assert + (forall ((u Int) (u1 (Array Int Int))) + (= (tb2t1 + (sort (map int int) (elts (sort (array1 int) (t2tb (mk_array1 u u1)))))) u1))) + +;; elts_def + (assert + (forall ((a ty)) + (forall ((u Int) (u1 uni)) + (= (sort (map int a) + (elts (sort (array1 a) (mk_array u (sort (map int a) u1))))) (sort + (map int a) + u1))))) + +;; array_inversion + (assert + (forall ((u (array Int))) + (= u (mk_array1 (length (sort (array1 int) (t2tb u))) + (tb2t1 (sort (map int int) (elts (sort (array1 int) (t2tb u))))))))) + +;; array_inversion + (assert + (forall ((a ty)) + (forall ((u uni)) + (= (sort (array1 a) u) (sort (array1 a) + (mk_array (length (sort (array1 a) u)) + (sort (map int a) (elts (sort (array1 a) u))))))))) + +(declare-fun get1 (deco Int) uni) + +(declare-fun t2tb2 (Int) uni) + +(declare-fun tb2t2 (deco) Int) + +;; BridgeL + (assert + (forall ((i Int)) + (! (= (tb2t2 (sort int (t2tb2 i))) i) :pattern ((sort int (t2tb2 i))) ))) + +;; BridgeR + (assert + (forall ((j uni)) + (! (= (sort int (t2tb2 (tb2t2 (sort int j)))) (sort int j)) :pattern ( + (sort int (t2tb2 (tb2t2 (sort int j))))) ))) + +;; get_def + (assert + (forall ((a (array Int)) (i Int)) + (= (tb2t2 (sort int (get1 (sort (array1 int) (t2tb a)) i))) (select + (tb2t1 (sort (map int int) (elts (sort (array1 int) (t2tb a))))) i)))) + +;; get_def + (assert + (forall ((a ty)) + (forall ((a1 uni) (i Int)) + (= (sort a (get1 (sort (array1 a) a1) i)) (sort a + (get + (sort (map int a) + (elts (sort (array1 a) a1))) + (sort int (t2tb2 i)))))))) + +(declare-fun set1 (deco Int deco) uni) + +;; set_def + (assert + (forall ((a (array Int)) (i Int) (v Int)) + (= (tb2t + (sort (array1 int) + (set1 (sort (array1 int) (t2tb a)) i (sort int (t2tb2 v))))) (mk_array1 + (length + (sort + (array1 + int) + (t2tb a))) + (store + (tb2t1 + (sort + (map + int + int) + (elts + (sort + (array1 + int) + (t2tb a))))) i v))))) + +;; set_def + (assert + (forall ((a ty)) + (forall ((a1 uni) (i Int) (v uni)) + (= (sort (array1 a) (set1 (sort (array1 a) a1) i (sort a v))) (sort + (array1 a) + (mk_array + (length + (sort + (array1 a) + a1)) + (sort + (map int a) + (set + (sort + (map int a) + (elts + (sort + (array1 a) + a1))) + (sort + int + (t2tb2 i)) + (sort a v))))))))) + +(declare-fun make (Int deco) uni) + +;; make_def + (assert + (forall ((n Int) (v Int)) + (= (tb2t (sort (array1 int) (make n (sort int (t2tb2 v))))) (mk_array1 n + (const2 v))))) + +;; make_def + (assert + (forall ((a ty)) + (forall ((n Int) (v uni)) + (= (sort (array1 a) (make n (sort a v))) (sort (array1 a) + (mk_array n + (sort (map int a) + (const1 (sort a v))))))))) + +(declare-fun sum ((Array Int Int) Int Int) Int) + +;; Sum_def_empty + (assert + (forall ((c (Array Int Int)) (i Int) (j Int)) + (=> (<= j i) (= (sum c i j) 0)))) + +;; Sum_def_non_empty + (assert + (forall ((c (Array Int Int)) (i Int) (j Int)) + (=> (< i j) (= (sum c i j) (+ (select c i) (sum c (+ i 1) j)))))) + +;; Sum_right_extension + (assert + (forall ((c (Array Int Int)) (i Int) (j Int)) + (=> (< i j) (= (sum c i j) (+ (sum c i (- j 1)) (select c (- j 1))))))) + +;; Sum_transitivity + (assert + (forall ((c (Array Int Int)) (i Int) (k Int) (j Int)) + (=> (and (<= i k) (<= k j)) (= (sum c i j) (+ (sum c i k) (sum c k j)))))) + +;; Sum_eq + (assert + (forall ((c1 (Array Int Int)) (c2 (Array Int Int)) (i Int) (j Int)) + (=> + (forall ((k Int)) + (=> (and (<= i k) (< k j)) (= (select c1 k) (select c2 k)))) + (= (sum c1 i j) (sum c2 i j))))) + +(declare-fun sum1 ((array Int) Int Int) Int) + +;; sum_def + (assert + (forall ((a (array Int)) (l Int) (h Int)) + (= (sum1 a l h) (sum + (tb2t1 + (sort (map int int) (elts (sort (array1 int) (t2tb a))))) l + h)))) + +(declare-fun is_max ((array Int) Int Int Int) Bool) + +;; is_max_def + (assert + (forall ((a (array Int)) (l Int) (h Int) (m Int)) + (and + (=> (is_max a l h m) + (and + (forall ((k Int)) + (=> (and (<= l k) (< k h)) + (<= (tb2t2 (sort int (get1 (sort (array1 int) (t2tb a)) k))) m))) + (or (and (<= h l) (= m 0)) + (and (< l h) + (exists ((k Int)) + (and (and (<= l k) (< k h)) + (= m (tb2t2 (sort int (get1 (sort (array1 int) (t2tb a)) k)))))))))) + (=> + (and + (forall ((k Int)) + (=> (and (<= l k) (< k h)) + (<= (tb2t2 (sort int (get1 (sort (array1 int) (t2tb a)) k))) m))) + (or (and (<= h l) (= m 0)) + (and (< l h) + (exists ((k Int)) + (and (and (<= l k) (< k h)) + (= m (tb2t2 (sort int (get1 (sort (array1 int) (t2tb a)) k))))))))) (is_max + a l h m))))) + +(assert +;; WP_parameter_test_case + ;; File "vstte10_max_sum/../vstte10_max_sum.mlw", line 63, characters 6-15 + (not + (=> (<= 0 20) + (=> (and (<= 0 0) (< 0 20)) + (forall ((a (Array Int Int))) + (=> (= a (store (const2 0) 0 9)) + (=> (and (<= 0 1) (< 1 20)) + (forall ((a1 (Array Int Int))) + (=> (= a1 (store a 1 5)) + (=> (and (<= 0 2) (< 2 20)) + (forall ((a2 (Array Int Int))) + (=> (= a2 (store a1 2 0)) + (=> (and (<= 0 3) (< 3 20)) + (forall ((a3 (Array Int Int))) + (=> (= a3 (store a2 3 2)) + (=> (and (<= 0 4) (< 4 20)) + (forall ((a4 (Array Int Int))) + (=> (= a4 (store a3 4 7)) + (=> (and (<= 0 5) (< 5 20)) + (forall ((a5 (Array Int Int))) + (=> (= a5 (store a4 5 3)) + (=> (and (<= 0 6) (< 6 20)) + (forall ((a6 (Array Int Int))) + (=> (= a6 (store a5 6 2)) + (=> (and (<= 0 7) (< 7 20)) + (forall ((a7 (Array Int Int))) + (=> (= a7 (store a6 7 1)) + (=> (and (<= 0 8) (< 8 20)) + (forall ((a8 (Array Int Int))) + (=> (= a8 (store a7 8 10)) + (=> (and (<= 0 9) (< 9 20)) + (forall ((a9 (Array Int Int))) + (=> (= a9 (store a8 9 6)) + (=> (and (<= 0 10) (< 10 20)) + (forall ((a10 (Array Int Int))) + (=> (= a10 (store a9 10 9)) + (=> (and (<= 0 11) (< 11 20)) + (forall ((a11 (Array Int Int))) + (=> (= a11 (store a10 11 5)) + (=> (and (<= 0 12) (< 12 20)) + (forall ((a12 (Array Int Int))) + (=> (= a12 (store a11 12 0)) + (=> (and (<= 0 13) (< 13 20)) + (forall ((a13 (Array Int Int))) + (=> (= a13 (store a12 13 2)) + (=> (and (<= 0 14) (< 14 20)) + (forall ((a14 (Array Int Int))) + (=> (= a14 (store a13 14 7)) + (=> (and (<= 0 15) (< 15 20)) + (forall ((a15 (Array Int Int))) + (=> (= a15 (store a14 15 3)) + (=> (and (<= 0 16) (< 16 20)) + (forall ((a16 (Array Int Int))) + (=> (= a16 (store a15 16 2)) + (=> (and (<= 0 17) (< 17 20)) + (forall ((a17 (Array Int Int))) + (=> (= a17 (store a16 17 1)) + (=> (and (<= 0 18) (< 18 20)) + (forall ((a18 (Array Int Int))) + (=> (= a18 (store a17 18 10)) + (=> (and (<= 0 19) (< 19 20)) + (forall ((a19 (Array Int Int))) + (=> (= a19 (store a18 19 6)) + (=> + (and (<= 0 20) + (forall ((i Int)) (=> (and (<= 0 i) (< i 20)) (<= 0 (select a19 i))))) + (forall ((result Int) (result1 Int)) + (=> + (and (= result (sum a19 0 20)) + (and (is_max (mk_array1 20 a19) 0 20 result1) (<= result (* 20 result1)))) + (= result 90))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) + diff --git a/test/regress/regress1/sep/Makefile.am b/test/regress/regress1/sep/Makefile.am index 3bf63ff1a..bda7e4484 100644 --- a/test/regress/regress1/sep/Makefile.am +++ b/test/regress/regress1/sep/Makefile.am @@ -20,7 +20,34 @@ TESTS = \ loop-1220.smt2 \ sep-simp-unc.smt2 \ split-find-unsat.smt2 \ - split-find-unsat-w-emp.smt2 + split-find-unsat-w-emp.smt2 \ + dispose-list-4-init.smt2 \ + finite-witness-sat.smt2 \ + sep-find2.smt2 \ + sep-fmf-priority.smt2 \ + sep-neg-1refine.smt2 \ + sep-nterm-again.smt2 \ + chain-int.smt2 \ + crash1220.smt2 \ + emp2-quant-unsat.smt2 \ + fmf-nemp-2.smt2 \ + pto-04.smt2 \ + quant_wand.smt2 \ + sep-02.smt2 \ + sep-03.smt2 \ + sep-neg-nstrict.smt2 \ + sep-neg-nstrict2.smt2 \ + sep-neg-simple.smt2 \ + sep-neg-swap.smt2 \ + sep-nterm-val-model.smt2 \ + simple-neg-sat.smt2 \ + wand-0526-sat.smt2 \ + wand-false.smt2 \ + wand-nterm-simp.smt2 \ + wand-nterm-simp2.smt2 \ + wand-simp-sat.smt2 \ + wand-simp-sat2.smt2 \ + wand-simp-unsat.smt2 EXTRA_DIST = $(TESTS) diff --git a/test/regress/regress1/sep/chain-int.smt2 b/test/regress/regress1/sep/chain-int.smt2 new file mode 100644 index 000000000..ebe52fa46 --- /dev/null +++ b/test/regress/regress1/sep/chain-int.smt2 @@ -0,0 +1,11 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(assert (sep (pto x y) (pto y z))) +(assert (and (> x 3) (< x 5))) +(assert (and (> y 3) (< y 5))) +(check-sat) diff --git a/test/regress/regress1/sep/crash1220.smt2 b/test/regress/regress1/sep/crash1220.smt2 new file mode 100644 index 000000000..f68434f33 --- /dev/null +++ b/test/regress/regress1/sep/crash1220.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +(declare-const x Int) +(declare-const a Int) + +(declare-const y Int) +(declare-const b Int) + +(assert (or (pto x a) (sep (pto x a) (pto y b)))) +(assert (or (not (pto x a)) (sep (not (pto x a)) (not (pto y b))))) + +(check-sat) diff --git a/test/regress/regress1/sep/dispose-list-4-init.smt2 b/test/regress/regress1/sep/dispose-list-4-init.smt2 new file mode 100644 index 000000000..b3e2088b1 --- /dev/null +++ b/test/regress/regress1/sep/dispose-list-4-init.smt2 @@ -0,0 +1,36 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) + +(declare-sort Loc 0) + +(declare-const w Loc) +(declare-const u1 Loc) +(declare-const u2 Loc) +(declare-const u3 Loc) +(declare-const nil Loc) + +(declare-const w1 Loc) +(declare-const w2 Loc) +(declare-const w3 Loc) +(declare-const w4 Loc) + +; allocated (not nil) +(assert (not (= w nil))) +(assert (not (= u1 nil))) +(assert (not (= u2 nil))) +(assert (not (= u3 nil))) +(assert (not (= w1 nil))) +(assert (not (= w2 nil))) +(assert (not (= w4 nil))) + +; from model +;(assert (= w1 u3)) +;(assert (= w2 u2)) +;(assert (= w3 u1)) +;(assert (= w4 u1)) + +(assert (sep (pto w u1) (pto u1 u2) (pto u2 u3) (pto u3 nil))) +(assert (and (sep (sep (pto w4 w1) (pto w1 w2) (pto w2 nil)) (pto w w3)) (sep (pto w w4) true))) + +(check-sat) diff --git a/test/regress/regress1/sep/emp2-quant-unsat.smt2 b/test/regress/regress1/sep/emp2-quant-unsat.smt2 new file mode 100644 index 000000000..e89c0fd30 --- /dev/null +++ b/test/regress/regress1/sep/emp2-quant-unsat.smt2 @@ -0,0 +1,12 @@ +; COMMAND-LINE: --quant-epr +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(declare-sort U 0) +(declare-fun u () U) + +(assert (sep (not (emp u u)) (not (emp u u)))) + +(assert (forall ((x U) (y U)) (= x y))) + +(check-sat) diff --git a/test/regress/regress1/sep/finite-witness-sat.smt2 b/test/regress/regress1/sep/finite-witness-sat.smt2 new file mode 100644 index 000000000..8aedbfd25 --- /dev/null +++ b/test/regress/regress1/sep/finite-witness-sat.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --finite-model-find --quant-epr --no-check-models +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(declare-sort Loc 0) +(declare-const l Loc) + +(assert (not (emp l l))) +(assert (forall ((x Loc) (y Loc)) (not (pto x y)))) + + +(check-sat) diff --git a/test/regress/regress1/sep/fmf-nemp-2.smt2 b/test/regress/regress1/sep/fmf-nemp-2.smt2 new file mode 100644 index 000000000..679b1e363 --- /dev/null +++ b/test/regress/regress1/sep/fmf-nemp-2.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --finite-model-find --no-check-models +; EXPECT: sat +(set-logic ALL_SUPPORTED) +(declare-sort U 0) +(declare-fun u1 () U) +(declare-fun u2 () U) +(assert (not (= u1 u2))) +(assert (forall ((x U)) (=> (not (= x (as sep.nil U))) (sep (not (emp u1 0)) (pto x 0))))) +; satisfiable with heap of size 2, model of U of size 3 +(check-sat) diff --git a/test/regress/regress1/sep/pto-04.smt2 b/test/regress/regress1/sep/pto-04.smt2 new file mode 100644 index 000000000..9b0afda7a --- /dev/null +++ b/test/regress/regress1/sep/pto-04.smt2 @@ -0,0 +1,36 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const x1 Int) +(declare-const x2 Int) +(declare-const x3 Int) +(declare-const x4 Int) +(declare-const x5 Int) +(declare-const x6 Int) +(declare-const x7 Int) +(declare-const x8 Int) +(declare-const x9 Int) + +(declare-const a1 Int) +(declare-const a2 Int) +(declare-const a3 Int) +(declare-const a4 Int) +(declare-const a5 Int) +(declare-const a6 Int) +(declare-const a7 Int) +(declare-const a8 Int) +(declare-const a9 Int) + +(assert (and (pto x1 a1) (pto x2 a2) (pto x3 a3) + (pto x4 a4) (pto x5 a5) (pto x6 a6) + (pto x7 a7) (pto x8 a8) (pto x9 a9) + ) +) + +(assert (not (and (= x1 x2 x3 x4 x5 x6 x7 x8 x9) + (= a1 a2 a3 a4 a5 a6 a7 a8 a9) + ) + ) +) + +(check-sat) diff --git a/test/regress/regress1/sep/quant_wand.smt2 b/test/regress/regress1/sep/quant_wand.smt2 new file mode 100644 index 000000000..8a69c10c4 --- /dev/null +++ b/test/regress/regress1/sep/quant_wand.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --full-saturate-quant +; EXPECT: unsat +(set-logic ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const u Int) + +(assert (emp 0 0)) + +(assert +(forall ((y Int)) +(not (wand (pto u 5) (and (= y 42) (pto u 5)))) +)) + +(check-sat) diff --git a/test/regress/regress1/sep/sep-02.smt2 b/test/regress/regress1/sep/sep-02.smt2 new file mode 100644 index 000000000..6f190d964 --- /dev/null +++ b/test/regress/regress1/sep/sep-02.smt2 @@ -0,0 +1,16 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) +(declare-const c Int) + +(assert (sep (pto x a) (pto y b) (pto z c))) + +(assert (or (= x y) (= y z) (= x z))) + +(check-sat) diff --git a/test/regress/regress1/sep/sep-03.smt2 b/test/regress/regress1/sep/sep-03.smt2 new file mode 100644 index 000000000..8dce5acc7 --- /dev/null +++ b/test/regress/regress1/sep/sep-03.smt2 @@ -0,0 +1,17 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const x Int) +(declare-const y Int) + +(declare-const a Int) +(declare-const b Int) + +(assert (and (sep (pto x a) (or (pto x a) (pto y b))) + (sep (pto y b) (or (pto x a) (pto y b))) + ) +) + +(assert (not (sep (pto x a) (pto y b)))) + +(check-sat) diff --git a/test/regress/regress1/sep/sep-find2.smt2 b/test/regress/regress1/sep/sep-find2.smt2 new file mode 100644 index 000000000..356f866c1 --- /dev/null +++ b/test/regress/regress1/sep/sep-find2.smt2 @@ -0,0 +1,22 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const x1 Int) +(declare-const x2 Int) +(declare-const x3 Int) +(declare-const x4 Int) +(declare-const x5 Int) +(declare-const x6 Int) +(declare-const x7 Int) + +(declare-const a1 Int) +(declare-const a2 Int) + +(assert (and +(sep (pto x1 a1) (pto x2 a2) (pto x4 a2) (pto x5 a2) (pto x6 a2) (pto x7 a2)) +(sep (pto x1 a1) (pto x3 a2)) +)) + +(assert (distinct x3 x2 x4 x5 x6 x7)) + +(check-sat) diff --git a/test/regress/regress1/sep/sep-fmf-priority.smt2 b/test/regress/regress1/sep/sep-fmf-priority.smt2 new file mode 100644 index 000000000..fe3af1b35 --- /dev/null +++ b/test/regress/regress1/sep/sep-fmf-priority.smt2 @@ -0,0 +1,12 @@ +; COMMAND-LINE: --finite-model-find --quant-epr --no-check-models +; EXPECT: sat +(set-logic ALL_SUPPORTED) + +(declare-sort Loc 0) +(declare-const l Loc) +(declare-const x Loc) + +(assert (wand (pto x x) false)) +(assert (forall ((x Loc) (y Loc)) (not (pto x y)))) + +(check-sat) diff --git a/test/regress/regress1/sep/sep-neg-1refine.smt2 b/test/regress/regress1/sep/sep-neg-1refine.smt2 new file mode 100644 index 000000000..ab12c6461 --- /dev/null +++ b/test/regress/regress1/sep/sep-neg-1refine.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) + +(assert (not (sep (pto x a) (pto y b)))) +(assert (sep (pto x a) (pto z b))) + +; sat with model where y != z +(check-sat) diff --git a/test/regress/regress1/sep/sep-neg-nstrict.smt2 b/test/regress/regress1/sep/sep-neg-nstrict.smt2 new file mode 100644 index 000000000..425e5ce3c --- /dev/null +++ b/test/regress/regress1/sep/sep-neg-nstrict.smt2 @@ -0,0 +1,15 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) + +(assert (not (sep true (pto x a)))) +(assert (sep (pto x a) (pto z b))) + + +(check-sat) diff --git a/test/regress/regress1/sep/sep-neg-nstrict2.smt2 b/test/regress/regress1/sep/sep-neg-nstrict2.smt2 new file mode 100644 index 000000000..7ada6ff06 --- /dev/null +++ b/test/regress/regress1/sep/sep-neg-nstrict2.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) + +(assert (not (= a b))) +(assert (not (sep true (pto x b)))) +(assert (sep (pto x a) (pto z b))) + + +(check-sat) diff --git a/test/regress/regress1/sep/sep-neg-simple.smt2 b/test/regress/regress1/sep/sep-neg-simple.smt2 new file mode 100644 index 000000000..7b6fc69e9 --- /dev/null +++ b/test/regress/regress1/sep/sep-neg-simple.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) + +(assert (not (pto x a))) +(assert (sep (pto x a) (pto z b))) + +(check-sat) diff --git a/test/regress/regress1/sep/sep-neg-swap.smt2 b/test/regress/regress1/sep/sep-neg-swap.smt2 new file mode 100644 index 000000000..53f890b0d --- /dev/null +++ b/test/regress/regress1/sep/sep-neg-swap.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) + +(assert (not (sep (pto y a) (pto x b)))) +(assert (sep (pto x a) (pto y b))) + + +(check-sat) diff --git a/test/regress/regress1/sep/sep-nterm-again.smt2 b/test/regress/regress1/sep/sep-nterm-again.smt2 new file mode 100644 index 000000000..3e595b5e9 --- /dev/null +++ b/test/regress/regress1/sep/sep-nterm-again.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) +(declare-const c Int) + +(assert (and + (not (sep (not (sep (not (pto x a)) (not (pto y b)))) (pto x a) )) + (sep (pto x a) (pto y b)) + ) +) + +(check-sat) diff --git a/test/regress/regress1/sep/sep-nterm-val-model.smt2 b/test/regress/regress1/sep/sep-nterm-val-model.smt2 new file mode 100644 index 000000000..d4fb0fd52 --- /dev/null +++ b/test/regress/regress1/sep/sep-nterm-val-model.smt2 @@ -0,0 +1,17 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) + +(assert (and + (not (sep (not (pto x a)) (not (pto y b)) )) + (sep (pto x (+ a 1)) (pto y (+ b 1))) + ) +) + +(check-sat) diff --git a/test/regress/regress1/sep/simple-neg-sat.smt2 b/test/regress/regress1/sep/simple-neg-sat.smt2 new file mode 100644 index 000000000..70927ad82 --- /dev/null +++ b/test/regress/regress1/sep/simple-neg-sat.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) + +(declare-const x Int) +(declare-const y Int) +(declare-const z Int) + +(declare-const a Int) +(declare-const b Int) +(declare-const c Int) + +(assert (and + (not (sep (not (pto x a)) (pto y b) )) + (sep (pto x a) (pto y b)) + ) +) + +(check-sat) diff --git a/test/regress/regress1/sep/wand-0526-sat.smt2 b/test/regress/regress1/sep/wand-0526-sat.smt2 new file mode 100644 index 000000000..12aa0a67e --- /dev/null +++ b/test/regress/regress1/sep/wand-0526-sat.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(declare-fun x () Int) +(declare-fun y () Int) +(declare-fun u () Int) +(declare-fun v () Int) +(assert (wand (pto x u) (pto y v))) +(assert (emp 0 0)) +(check-sat) diff --git a/test/regress/regress1/sep/wand-false.smt2 b/test/regress/regress1/sep/wand-false.smt2 new file mode 100644 index 000000000..65500f775 --- /dev/null +++ b/test/regress/regress1/sep/wand-false.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) +(declare-fun x () Int) +(assert (wand (pto x x) false)) +(check-sat) diff --git a/test/regress/regress1/sep/wand-nterm-simp.smt2 b/test/regress/regress1/sep/wand-nterm-simp.smt2 new file mode 100644 index 000000000..b59b53b58 --- /dev/null +++ b/test/regress/regress1/sep/wand-nterm-simp.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(declare-fun x () Int) +(assert (wand (emp x x) (pto x 3))) +(check-sat) + diff --git a/test/regress/regress1/sep/wand-nterm-simp2.smt2 b/test/regress/regress1/sep/wand-nterm-simp2.smt2 new file mode 100644 index 000000000..fa6a83143 --- /dev/null +++ b/test/regress/regress1/sep/wand-nterm-simp2.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) +(declare-fun x () Int) +(assert (wand (pto x 1) (emp x x))) +(check-sat) diff --git a/test/regress/regress1/sep/wand-simp-sat.smt2 b/test/regress/regress1/sep/wand-simp-sat.smt2 new file mode 100644 index 000000000..120683f74 --- /dev/null +++ b/test/regress/regress1/sep/wand-simp-sat.smt2 @@ -0,0 +1,6 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(declare-fun x () Int) +(assert (wand (pto x 1) (pto x 1))) +(check-sat) diff --git a/test/regress/regress1/sep/wand-simp-sat2.smt2 b/test/regress/regress1/sep/wand-simp-sat2.smt2 new file mode 100644 index 000000000..c684d16ad --- /dev/null +++ b/test/regress/regress1/sep/wand-simp-sat2.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) +(declare-fun x () Int) +(assert (wand (pto x 1) (pto x 3))) +(check-sat) diff --git a/test/regress/regress1/sep/wand-simp-unsat.smt2 b/test/regress/regress1/sep/wand-simp-unsat.smt2 new file mode 100644 index 000000000..850be7b97 --- /dev/null +++ b/test/regress/regress1/sep/wand-simp-unsat.smt2 @@ -0,0 +1,7 @@ +; COMMAND-LINE: --no-check-models +; EXPECT: unsat +(set-logic QF_ALL_SUPPORTED) +(declare-fun x () Int) +(assert (wand (pto x 1) (pto x 3))) +(assert (emp x x)) +(check-sat) diff --git a/test/regress/regress1/sets/ListElem.hs.fqout.cvc4.38.smt2 b/test/regress/regress1/sets/ListElem.hs.fqout.cvc4.38.smt2 new file mode 100644 index 000000000..3c0ef1dda --- /dev/null +++ b/test/regress/regress1/sets/ListElem.hs.fqout.cvc4.38.smt2 @@ -0,0 +1,59 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) + +; What was the bug? +; +; When asserting equality to equality engine, correct reason +; was not being sent (the fact itself was being sent as reason) + +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2))) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) +(declare-fun z3v56 () Int) +(declare-fun z3v57 () Int) +(assert (distinct z3v56 z3v57)) +(declare-fun z3v58 () Int) +(declare-fun z3f59 (Int) Int) +(declare-fun z3v60 () Int) +(declare-fun z3f61 (Int) Bool) +(declare-fun z3v62 () Int) +(declare-fun z3v63 () Int) +(declare-fun z3v64 () Int) +(declare-fun z3v65 () Int) +(declare-fun z3f66 (Int) mySet) +(declare-fun z3f67 (Int) Bool) +(declare-fun z3f68 (Int Int) Int) +(declare-fun z3v69 () Int) +(declare-fun z3v70 () Int) +(declare-fun z3f71 (Int) Int) +(declare-fun z3v72 () Int) +(declare-fun z3v73 () Int) +(declare-fun z3v74 () Int) +(declare-fun z3v75 () Int) +(declare-fun z3v76 () Int) +(declare-fun z3v77 () Int) +(declare-fun z3v78 () Int) +(declare-fun z3v80 () Int) +(declare-fun z3v81 () Int) +(declare-fun z3f82 () Int) +(declare-fun z3v83 () Int) +(declare-fun z3v84 () Int) +(declare-fun z3v85 () Int) +(declare-fun z3v86 () Int) +(declare-fun z3v87 () Int) +(declare-fun z3v88 () Int) +(declare-fun z3v89 () Int) +(declare-fun z3v90 () Int) +(assert (= z3v90 z3v56)) +(assert (z3f61 z3v90)) +(assert (and (>= (z3f59 z3v58) 0) (z3f61 z3v60) (z3f61 z3v60) (= z3v60 z3v62) (= (z3f61 z3v60) (= z3v64 z3v63)) (= (z3f61 z3v62) (= z3v64 z3v63)) (>= (z3f59 z3v65) 0) (= (z3f66 z3v65) (smt_set_cup (smt_set_add smt_set_emp z3v64) (z3f66 z3v58))) (= (z3f59 z3v65) (+ 1 (z3f59 z3v58))) (= (z3f67 z3v65) false) (= z3v65 (z3f68 z3v64 z3v58)) (>= (z3f59 z3v65) 0) (= z3v65 z3v69) (>= (z3f59 z3v65) 0) (>= (z3f59 z3v69) 0) (z3f61 z3v56) (= (z3f71 z3v70) z3v70) (= (z3f71 z3v72) z3v72) (not (z3f61 z3v57)) (= (z3f71 z3v73) z3v73))) +(assert (not (= (z3f61 z3v90) (smt_set_mem z3v63 (z3f66 z3v69))))) +(check-sat) diff --git a/test/regress/regress1/sets/ListElts.hs.fqout.cvc4.317.smt2 b/test/regress/regress1/sets/ListElts.hs.fqout.cvc4.317.smt2 new file mode 100644 index 000000000..7b5294aec --- /dev/null +++ b/test/regress/regress1/sets/ListElts.hs.fqout.cvc4.317.smt2 @@ -0,0 +1,98 @@ +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2))) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) +(declare-fun z3v58 () Int) +(declare-fun z3v59 () Int) +(assert (distinct z3v58 z3v59)) +(declare-fun z3f60 (Int) Bool) +(declare-fun z3v61 () Int) +(declare-fun z3f62 (Int) Int) +(declare-fun z3v63 () Int) +(declare-fun z3v64 () Int) +(declare-fun z3v67 () Int) +(declare-fun z3f68 (Int) Int) +(declare-fun z3f69 (Int) mySet) +(declare-fun z3f70 (Int) mySet) +(declare-fun z3f71 (Int) Bool) +(declare-fun z3v73 () Int) +(declare-fun z3v76 () Int) +(declare-fun z3v79 () Int) +(declare-fun z3v82 () Int) +(declare-fun z3v84 () Int) +(declare-fun z3v85 () Int) +(declare-fun z3v86 () Int) +(declare-fun z3v89 () Int) +(declare-fun z3v90 () Int) +(declare-fun z3v91 () Int) +(declare-fun z3f92 (Int Int) Int) +(declare-fun z3v93 () Int) +(declare-fun z3v94 () Int) +(declare-fun z3f96 () Int) +(declare-fun z3v97 () Int) +(declare-fun z3v98 () Int) +(declare-fun z3v99 () Int) +(declare-fun z3v100 () Int) +(declare-fun z3v101 () Int) +(declare-fun z3v102 () Int) +(declare-fun z3v104 () Int) +(declare-fun z3v107 () Int) +(declare-fun z3v110 () Int) +(declare-fun z3v113 () Int) +(declare-fun z3v116 () Int) +(declare-fun z3v117 () Int) +(declare-fun z3v118 () Int) +(declare-fun z3v119 () Int) +(declare-fun z3v120 () Int) +(declare-fun z3v121 () Int) +(declare-fun z3v122 () Int) +(declare-fun z3v123 () Int) +(declare-fun z3v124 () Int) +(declare-fun z3v125 () Int) +(declare-fun z3v127 () Int) +(declare-fun z3v130 () Int) +(declare-fun z3v133 () Int) +(declare-fun z3v134 () Int) +(declare-fun z3v135 () Int) +(declare-fun z3v136 () Int) +(declare-fun z3v137 () Int) +(declare-fun z3v140 () Int) +(declare-fun z3v141 () Int) +(declare-fun z3v142 () Int) +(declare-fun z3v143 () Int) +(declare-fun z3v144 () Int) +(declare-fun z3v145 () Int) +(declare-fun z3v147 () Int) +(declare-fun z3v150 () Int) +(declare-fun z3v151 () Int) +(declare-fun z3v152 () Int) +(assert (= (z3f69 z3v152) (smt_set_cup (smt_set_add smt_set_emp z3v143) (z3f69 z3v151)))) +(assert (= (z3f70 z3v152) (smt_set_cup (smt_set_add smt_set_emp z3v143) (z3f70 z3v151)))) +(assert (= (z3f68 z3v152) (+ 1 (z3f68 z3v151)))) +(assert (= (z3f71 z3v152) false)) +(assert (and (>= (z3f68 z3v140) 0) (>= (z3f68 z3v141) 0) (>= (z3f68 z3v151) 0) (>= (z3f68 z3v142) 0) (= (z3f69 z3v142) (smt_set_cup (smt_set_add smt_set_emp z3v143) (z3f69 z3v141))) (= (z3f70 z3v142) (smt_set_cup (smt_set_add smt_set_emp z3v143) (z3f70 z3v141))) (= (z3f68 z3v142) (+ 1 (z3f68 z3v141))) (= (z3f71 z3v142) false) (= z3v142 (z3f92 z3v143 z3v141)) (>= (z3f68 z3v142) 0) (= z3v142 z3v144) (>= (z3f68 z3v142) 0) (>= (z3f68 z3v144) 0) (z3f60 z3v58) (= (z3f62 z3v61) z3v61) (= (z3f62 z3v63) z3v63) (not (z3f60 z3v59)) (= (z3f62 z3v64) z3v64))) +(assert (= (z3f69 z3v151) (smt_set_cup (z3f69 z3v140) (z3f69 z3v141)))) +(assert (= (z3f69 z3v151) (smt_set_cup (z3f69 z3v140) (z3f69 z3v140)))) +(assert (= (z3f69 z3v151) (smt_set_cup (z3f69 z3v141) (z3f69 z3v140)))) +(assert (smt_set_sub (z3f69 z3v151) (z3f69 z3v140))) +(assert (= (z3f69 z3v151) (z3f69 z3v140))) +(assert (<= z3v151 z3v140)) +(assert (>= z3v151 z3v140)) +(assert (<= (z3f68 z3v151) (z3f68 z3v140))) +(assert (>= (z3f68 z3v151) (z3f68 z3v141))) +(assert (>= (z3f68 z3v151) (z3f68 z3v140))) +(assert (= (z3f68 z3v151) (z3f68 z3v140))) +(assert (= z3v151 z3v140)) +(assert (>= (z3f68 z3v151) 0)) +(assert (not (= (z3f69 z3v152) (smt_set_cup (z3f69 z3v140) (z3f69 z3v140))))) +(check-sat) diff --git a/test/regress/regress1/sets/Makefile.am b/test/regress/regress1/sets/Makefile.am index b09a25303..f52ab44e7 100644 --- a/test/regress/regress1/sets/Makefile.am +++ b/test/regress/regress1/sets/Makefile.am @@ -18,9 +18,34 @@ endif # put it below in "TESTS +=" TESTS = \ sets-disequal.smt2 \ - card-vc6-minimized.smt2 - -EXTRA_DIST = $(TESTS) + card-vc6-minimized.smt2 \ + card-4.smt2 \ + fuzz15201.smt2 \ + insert_invariant_37_2.smt2 \ + remove_check_free_31_6.smt2 \ + TalkingAboutSets.hs.fqout.cvc4.3577.smt2 \ + arjun-set-univ.cvc \ + card-3.smt2 \ + card-5.smt2 \ + card-6.smt2 \ + card-7.smt2 \ + copy_check_heap_access_33_4.smt2 \ + deepmeas0.hs.fqout.cvc4.41.smt2 \ + fuzz14418.smt2 \ + fuzz31811.smt2 \ + lemmabug-ListElts317minimized.smt2 \ + ListElem.hs.fqout.cvc4.38.smt2 \ + ListElts.hs.fqout.cvc4.317.smt2 \ + sets-tuple-poly.cvc \ + sharingbug.smt2 \ + UniqueZipper.hs.1030minimized.cvc4.smt2 \ + UniqueZipper.hs.1030minimized2.cvc4.smt2 \ + UniqueZipper.hs.fqout.cvc4.10.smt2 \ + UniqueZipper.hs.fqout.cvc4.1832.smt2 \ + univ-set-uf-elim.smt2 + +EXTRA_DIST = $(TESTS) \ + setofsets-disequal.smt2 # synonyms for "check" in this directory .PHONY: regress regress1 test diff --git a/test/regress/regress1/sets/TalkingAboutSets.hs.fqout.cvc4.3577.smt2 b/test/regress/regress1/sets/TalkingAboutSets.hs.fqout.cvc4.3577.smt2 new file mode 100644 index 000000000..282325f14 --- /dev/null +++ b/test/regress/regress1/sets/TalkingAboutSets.hs.fqout.cvc4.3577.smt2 @@ -0,0 +1,286 @@ +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2))) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) +(declare-fun z3v60 () Int) +(declare-fun z3v61 () Int) +(assert (distinct z3v60 z3v61)) +(declare-fun z3f62 (Int) Bool) +(declare-fun z3v63 () Int) +(declare-fun z3f64 (Int) Int) +(declare-fun z3v65 () Int) +(declare-fun z3v66 () Int) +(declare-fun z3v69 () mySet) +(declare-fun z3v70 () mySet) +(declare-fun z3v72 () mySet) +(declare-fun z3v73 () mySet) +(declare-fun z3v75 () Int) +(declare-fun z3f76 (Int) Int) +(declare-fun z3v79 () Int) +(declare-fun z3v80 () Int) +(declare-fun z3v84 () Int) +(declare-fun z3v87 () mySet) +(declare-fun z3v88 () mySet) +(declare-fun z3v90 () mySet) +(declare-fun z3v91 () mySet) +(declare-fun z3v93 () mySet) +(declare-fun z3v94 () mySet) +(declare-fun z3v96 () Int) +(declare-fun z3f97 (Int) mySet) +(declare-fun z3f98 (Int) Bool) +(declare-fun z3v99 () Int) +(declare-fun z3v102 () Int) +(declare-fun z3v105 () mySet) +(declare-fun z3v107 () mySet) +(declare-fun z3v108 () mySet) +(declare-fun z3v109 () Int) +(declare-fun z3v110 () Int) +(declare-fun z3v111 () Int) +(declare-fun z3v112 () Int) +(declare-fun z3v113 () mySet) +(declare-fun z3v114 () mySet) +(declare-fun z3v117 () mySet) +(declare-fun z3v118 () mySet) +(declare-fun z3v121 () mySet) +(declare-fun z3v123 () mySet) +(declare-fun z3v124 () mySet) +(declare-fun z3v126 () mySet) +(declare-fun z3v128 () Int) +(declare-fun z3v132 () Int) +(declare-fun z3v135 () mySet) +(declare-fun z3v136 () mySet) +(declare-fun z3v138 () mySet) +(declare-fun z3v140 () Int) +(declare-fun z3v143 () mySet) +(declare-fun z3v144 () mySet) +(declare-fun z3v145 () mySet) +(declare-fun z3v146 () Int) +(declare-fun z3v147 () Int) +(declare-fun z3v148 () mySet) +(declare-fun z3v149 () mySet) +(declare-fun z3v155 () mySet) +(declare-fun z3v156 () mySet) +(declare-fun z3v157 () mySet) +(declare-fun z3v160 () Int) +(declare-fun z3v161 () Int) +(declare-fun z3v162 () Int) +(declare-fun z3v163 () Int) +(declare-fun z3v164 () mySet) +(declare-fun z3v165 () mySet) +(declare-fun z3v169 () Int) +(declare-fun z3v172 () mySet) +(declare-fun z3v173 () mySet) +(declare-fun z3v175 () Int) +(declare-fun z3v176 () Int) +(declare-fun z3v177 () Int) +(declare-fun z3v178 () Int) +(declare-fun z3f179 (Int Int) Int) +(declare-fun z3v180 () Int) +(declare-fun z3v181 () Int) +(declare-fun z3f183 () Int) +(declare-fun z3v184 () Int) +(declare-fun z3v185 () Int) +(declare-fun z3v186 () Int) +(declare-fun z3v187 () Int) +(declare-fun z3v188 () Int) +(declare-fun z3v189 () Int) +(declare-fun z3v192 () Int) +(declare-fun z3v193 () Int) +(declare-fun z3v197 () Int) +(declare-fun z3v198 () mySet) +(declare-fun z3v200 () Int) +(declare-fun z3v201 () Int) +(declare-fun z3v202 () Int) +(declare-fun z3v203 () Int) +(declare-fun z3v204 () Int) +(declare-fun z3v206 () Int) +(declare-fun z3v207 () Int) +(declare-fun z3v208 () Int) +(declare-fun z3v209 () Int) +(declare-fun z3v210 () Int) +(declare-fun z3v211 () Int) +(declare-fun z3f212 (Int) Int) +(declare-fun z3f213 (Int) Int) +(declare-fun z3v214 () Int) +(declare-fun z3v215 () Int) +(declare-fun z3v217 () Int) +(declare-fun z3v218 () Int) +(declare-fun z3v219 () Int) +(declare-fun z3v220 () Int) +(declare-fun z3f221 (Int Int) Int) +(declare-fun z3v222 () Int) +(declare-fun z3v223 () Int) +(declare-fun z3v224 () Int) +(declare-fun z3v225 () Int) +(declare-fun z3v226 () Int) +(declare-fun z3v227 () Int) +(declare-fun z3v228 () Int) +(declare-fun z3v229 () Int) +(declare-fun z3v230 () Int) +(declare-fun z3v231 () Int) +(declare-fun z3v232 () Int) +(declare-fun z3v233 () Int) +(declare-fun z3v234 () Int) +(declare-fun z3v235 () Int) +(declare-fun z3v236 () Int) +(declare-fun z3v237 () Int) +(declare-fun z3v238 () Int) +(declare-fun z3v239 () Int) +(declare-fun z3v240 () Int) +(declare-fun z3v241 () Int) +(declare-fun z3v242 () Int) +(declare-fun z3v243 () Int) +(declare-fun z3v244 () Int) +(declare-fun z3v245 () Int) +(declare-fun z3v246 () Int) +(declare-fun z3v247 () Int) +(declare-fun z3v248 () Int) +(declare-fun z3v249 () Int) +(declare-fun z3v250 () Int) +(declare-fun z3v251 () Int) +(declare-fun z3v252 () Int) +(declare-fun z3v253 () Int) +(declare-fun z3v254 () Int) +(declare-fun z3v255 () Int) +(declare-fun z3v256 () Int) +(declare-fun z3v257 () Int) +(declare-fun z3v258 () Int) +(declare-fun z3v259 () Int) +(declare-fun z3v260 () Int) +(declare-fun z3v261 () Int) +(declare-fun z3v262 () Int) +(declare-fun z3v263 () Int) +(declare-fun z3v264 () Int) +(declare-fun z3v265 () Int) +(declare-fun z3v266 () Int) +(declare-fun z3v267 () Int) +(declare-fun z3v268 () Int) +(declare-fun z3v269 () Int) +(declare-fun z3v271 () Int) +(declare-fun z3v273 () Int) +(declare-fun z3v275 () Int) +(declare-fun z3v277 () Int) +(declare-fun z3v279 () Int) +(declare-fun z3v281 () Int) +(declare-fun z3v283 () Int) +(declare-fun z3v286 () Int) +(declare-fun z3v289 () Int) +(declare-fun z3v290 () Int) +(declare-fun z3v291 () Int) +(declare-fun z3v292 () mySet) +(declare-fun z3v295 () mySet) +(declare-fun z3v297 () Int) +(declare-fun z3v301 () Int) +(declare-fun z3v302 () Int) +(declare-fun z3v303 () Int) +(declare-fun z3v304 () Int) +(declare-fun z3v305 () Int) +(declare-fun z3v306 () Int) +(declare-fun z3v307 () Int) +(declare-fun z3v308 () Int) +(declare-fun z3v309 () Int) +(declare-fun z3v310 () Int) +(declare-fun z3v312 () Int) +(declare-fun z3v314 () Int) +(declare-fun z3v315 () Int) +(declare-fun z3v316 () Int) +(declare-fun z3v317 () Int) +(declare-fun z3v318 () Int) +(declare-fun z3v319 () Int) +(declare-fun z3v320 () Int) +(declare-fun z3v321 () Int) +(declare-fun z3v322 () Int) +(declare-fun z3v324 () Int) +(declare-fun z3v327 () Int) +(declare-fun z3v328 () Int) +(declare-fun z3v329 () Int) +(declare-fun z3v330 () Int) +(declare-fun z3v331 () Int) +(declare-fun z3v332 () Int) +(declare-fun z3v333 () Int) +(declare-fun z3v334 () Int) +(declare-fun z3v335 () Int) +(declare-fun z3v336 () Int) +(declare-fun z3v337 () Int) +(declare-fun z3v338 () Int) +(declare-fun z3v339 () Int) +(declare-fun z3v340 () Int) +(declare-fun z3v341 () Int) +(declare-fun z3v342 () Int) +(declare-fun z3v343 () Int) +(declare-fun z3v345 () Int) +(declare-fun z3v349 () Int) +(declare-fun z3v350 () Int) +(declare-fun z3v351 () Int) +(declare-fun z3v352 () Int) +(declare-fun z3v353 () Int) +(declare-fun z3v354 () Int) +(declare-fun z3v355 () Int) +(declare-fun z3v359 () Int) +(declare-fun z3v361 () Int) +(declare-fun z3v362 () Int) +(declare-fun z3v363 () Int) +(declare-fun z3v364 () Int) +(declare-fun z3v366 () Int) +(declare-fun z3v367 () Int) +(declare-fun z3v368 () Int) +(declare-fun z3v369 () Int) +(declare-fun z3v370 () Int) +(declare-fun z3v375 () Int) +(assert (= (z3f97 z3v328) (smt_set_cup (z3f97 z3v331) (z3f97 z3v375)))) +(assert (= (z3f97 z3v328) (smt_set_cup (z3f97 z3v330) (z3f97 z3v375)))) +(assert (= (z3f97 z3v328) (smt_set_cup (z3f97 z3v328) (z3f97 z3v375)))) +(assert (= (z3f97 z3v328) (smt_set_cup (z3f97 z3v327) (z3f97 z3v375)))) +(assert (= (z3f97 z3v331) (smt_set_cup (z3f97 z3v331) (z3f97 z3v375)))) +(assert (= (z3f97 z3v331) (smt_set_cup (z3f97 z3v330) (z3f97 z3v375)))) +(assert (= (z3f97 z3v331) (smt_set_cup (z3f97 z3v328) (z3f97 z3v375)))) +(assert (= (z3f97 z3v331) (smt_set_cup (z3f97 z3v327) (z3f97 z3v375)))) +(assert (= (z3f97 z3v375) (z3f97 z3v331))) +(assert (= (z3f97 z3v375) (z3f97 z3v328))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v327) (z3f97 z3v331)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v327) (z3f97 z3v328)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v328) (z3f97 z3v331)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v328) (z3f97 z3v330)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v328) (z3f97 z3v328)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v328) (z3f97 z3v327)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v330) (z3f97 z3v331)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v330) (z3f97 z3v328)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v331) (z3f97 z3v331)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v331) (z3f97 z3v330)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v331) (z3f97 z3v328)))) +(assert (= (z3f97 z3v375) (smt_set_cup (z3f97 z3v331) (z3f97 z3v327)))) +(assert (smt_set_sub (z3f97 z3v375) (z3f97 z3v331))) +(assert (smt_set_sub (z3f97 z3v375) (z3f97 z3v328))) +(assert (<= z3v375 z3v331)) +(assert (<= z3v375 z3v328)) +(assert (= z3v375 z3v328)) +(assert (>= z3v375 z3v331)) +(assert (>= z3v375 z3v328)) +(assert (not (= z3v375 z3v330))) +(assert (not (= z3v375 z3v327))) +(assert (<= (z3f76 z3v375) (z3f76 z3v331))) +(assert (<= (z3f76 z3v375) (z3f76 z3v328))) +(assert (> (z3f76 z3v375) (z3f76 z3v330))) +(assert (> (z3f76 z3v375) (z3f76 z3v327))) +(assert (>= (z3f76 z3v375) (z3f76 z3v331))) +(assert (>= (z3f76 z3v375) (z3f76 z3v330))) +(assert (>= (z3f76 z3v375) (z3f76 z3v328))) +(assert (>= (z3f76 z3v375) (z3f76 z3v327))) +(assert (= (z3f76 z3v375) (z3f76 z3v331))) +(assert (= (z3f76 z3v375) (z3f76 z3v328))) +(assert (> (z3f76 z3v375) 0)) +(assert (= z3v375 z3v331)) +(assert (>= (z3f76 z3v375) 0)) +(assert (and (>= (z3f76 z3v327) 0) (>= (z3f76 z3v328) 0) (= (z3f97 z3v328) (smt_set_cup (smt_set_add smt_set_emp z3v329) (z3f97 z3v330))) (= (z3f76 z3v328) (+ 1 (z3f76 z3v330))) (= (z3f98 z3v328) false) (= z3v328 (z3f179 z3v329 z3v330)) (>= (z3f76 z3v328) 0) (= z3v328 z3v331) (>= (z3f76 z3v328) 0) (>= (z3f76 z3v330) 0) (>= (z3f76 z3v331) 0) (z3f62 z3v60) (= (z3f64 z3v63) z3v63) (= (z3f64 z3v65) z3v65) (not (z3f62 z3v61)) (= (z3f64 z3v66) z3v66))) +(assert (not (= (z3f97 z3v327) (smt_set_cup (z3f97 z3v327) (z3f97 z3v375))))) +(check-sat) diff --git a/test/regress/regress1/sets/UniqueZipper.hs.1030minimized.cvc4.smt2 b/test/regress/regress1/sets/UniqueZipper.hs.1030minimized.cvc4.smt2 new file mode 100644 index 000000000..38477c46a --- /dev/null +++ b/test/regress/regress1/sets/UniqueZipper.hs.1030minimized.cvc4.smt2 @@ -0,0 +1,209 @@ +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) + +(declare-fun z3v66 () Int) +(declare-fun z3v67 () Int) +(assert (distinct z3v66 z3v67)) + +(declare-fun z3f70 (Int) mySet) +(declare-fun z3f72 (Int) mySet) +(declare-fun z3f76 (Int) Bool) +(declare-fun z3f77 (Int Int) Int) +(declare-fun z3v78 () Int) +(declare-fun z3f79 (Int) Bool) +(declare-fun z3v80 () Int) +(declare-fun z3f81 (Int) Int) +(declare-fun z3v82 () Int) +(declare-fun z3v83 () Int) +(declare-fun z3v85 () Int) +(declare-fun z3v86 () Int) +(declare-fun z3v87 () Int) +(declare-fun z3f88 () Int) +(declare-fun z3v89 () Int) +(declare-fun z3v90 () Int) +(declare-fun z3v91 () Int) +(declare-fun z3v92 () Int) +(declare-fun z3v93 () Int) +(declare-fun z3f94 (Int) Int) +(declare-fun z3f95 (Int) Int) +(declare-fun z3f96 (Int Int Int) Int) +(declare-fun z3v97 () Int) +(declare-fun z3v98 () Int) +(declare-fun z3v99 () Int) +(declare-fun z3v100 () Int) +(declare-fun z3v101 () Int) +(declare-fun z3v102 () Int) +(declare-fun z3v103 () Int) +(declare-fun z3v104 () Int) +(declare-fun z3v105 () Int) +(declare-fun z3v106 () Int) +(declare-fun z3v107 () Int) +(declare-fun z3v108 () Int) +(declare-fun z3v109 () Int) +(declare-fun z3v110 () Int) +(declare-fun z3v113 () Int) +(declare-fun z3v114 () Int) +(declare-fun z3v115 () Int) +(declare-fun z3v116 () Int) +(declare-fun z3v117 () Int) +(declare-fun z3v118 () Int) +(declare-fun z3v120 () Int) +(declare-fun z3v121 () Int) +(declare-fun z3v122 () Int) +(declare-fun z3v124 () Int) +(declare-fun z3v125 () Int) +(declare-fun z3v126 () Int) +(declare-fun z3v127 () Int) +(declare-fun z3v128 () Int) +(declare-fun z3v129 () Int) +(declare-fun z3v131 () Int) +(declare-fun z3v132 () Int) +(declare-fun z3v133 () Int) +(declare-fun z3v134 () Int) +(declare-fun z3v135 () Int) +(declare-fun z3v136 () Int) +(declare-fun z3v137 () Int) +(declare-fun z3v138 () Int) +(declare-fun z3v139 () Int) +(declare-fun z3v140 () Int) +(declare-fun z3v141 () Int) +(declare-fun z3v142 () Int) +(declare-fun z3v144 () Int) +(declare-fun z3v145 () Int) +(declare-fun z3v146 () Int) +(declare-fun z3v149 () Int) +(declare-fun z3v151 () Int) +(declare-fun z3v154 () Int) +(declare-fun z3v155 () Int) +(declare-fun z3v156 () Int) +(declare-fun z3v157 () Int) +(declare-fun z3v158 () Int) +(declare-fun z3v159 () Int) +(declare-fun z3v161 () Int) +(declare-fun z3v163 () Int) +(declare-fun z3v164 () Int) +(declare-fun z3v165 () Int) +(declare-fun z3v167 () Int) +(declare-fun z3v170 () Int) +(declare-fun z3v174 () Int) +(declare-fun z3v175 () Int) +(declare-fun z3v176 () Int) +(declare-fun z3v179 () Int) +(declare-fun z3v181 () Int) +(declare-fun z3v182 () Int) +(declare-fun z3v183 () Int) +(declare-fun z3v184 () Int) +(declare-fun z3v187 () Int) +(declare-fun z3v188 () Int) +(declare-fun z3v189 () Int) +(declare-fun z3v190 () Int) +(declare-fun z3f191 (Int) Int) +(declare-fun z3f192 (Int) Int) +(declare-fun z3v195 () Int) +(declare-fun z3v196 () Int) +(declare-fun z3v199 () Int) +(declare-fun z3v200 () Int) +(declare-fun z3v201 () Int) +(declare-fun z3v202 () Int) +(declare-fun z3v203 () Int) +(declare-fun z3v206 () Int) +(declare-fun z3v207 () Int) +(declare-fun z3v208 () Int) +(declare-fun z3v210 () Int) +(declare-fun z3v211 () Int) +(declare-fun z3v212 () Int) +(declare-fun z3f213 (Int) Bool) +(declare-fun z3f214 (Int) Int) +(declare-fun z3v215 () Int) +(declare-fun z3v216 () Int) +(declare-fun z3v218 () Int) +(declare-fun z3v220 () Int) +(declare-fun z3v221 () Int) +(declare-fun z3v222 () Int) +(declare-fun z3v223 () Int) +(declare-fun z3v224 () Int) +(declare-fun z3v225 () Int) +(declare-fun z3v226 () Int) +(declare-fun z3v227 () Int) +(declare-fun z3v228 () Int) +(declare-fun z3v229 () Int) +(declare-fun z3v230 () Int) +(declare-fun z3v231 () Int) +(declare-fun z3v233 () Int) +(declare-fun z3v236 () Int) +(declare-fun z3v242 () Int) +(declare-fun z3v243 () Int) +(declare-fun z3v244 () Int) +(declare-fun z3v245 () Int) +(declare-fun z3v247 () Int) +(declare-fun z3v248 () Int) +(declare-fun z3v249 () Int) +(declare-fun z3v250 () Int) +(declare-fun z3v251 () Int) +(declare-fun z3v252 () Int) +(declare-fun z3v253 () Int) +(declare-fun z3v255 () Int) +(declare-fun z3v256 () Int) +(declare-fun z3v258 () Int) +(declare-fun z3v259 () Int) +(declare-fun z3v261 () Int) +(declare-fun z3v262 () Int) +(declare-fun z3v263 () Int) +(declare-fun z3v264 () Int) +(declare-fun z3v266 () Int) +(declare-fun z3v268 () Int) +(declare-fun z3v270 () Int) +(declare-fun z3v271 () Int) +(declare-fun z3v272 () Int) + +(assert (and (not (smt_set_mem z3v132 (z3f70 z3v131))) + (= (z3f72 z3v131) smt_set_emp) + (= (z3f72 z3v133) smt_set_emp) + (= (z3f72 z3v242) + (ite (smt_set_mem z3v271 (z3f70 z3v270)) + (smt_set_cup (smt_set_add smt_set_emp z3v271) + (z3f72 z3v270)) + (z3f72 z3v270))) + (= (z3f70 z3v242) + (smt_set_cup (smt_set_add smt_set_emp z3v271) + (z3f70 z3v270))) + (= z3v242 (z3f77 z3v271 z3v270)) + (= z3v242 z3v243) + (smt_set_sub (z3f70 z3v242) + (z3f70 z3v244)) + (= (z3f72 z3v242) smt_set_emp) + (smt_set_sub (z3f70 z3v243) + (z3f70 z3v244)) + (= (z3f72 z3v243) smt_set_emp) + (= (z3f72 z3v244) + (ite (smt_set_mem z3v132 (z3f70 z3v131)) + (smt_set_cup (smt_set_add smt_set_emp z3v132) + (z3f72 z3v131)) + (z3f72 z3v131))) + (= (z3f70 z3v244) + (smt_set_cup (smt_set_add smt_set_emp z3v132) + (z3f70 z3v131))) + (= (z3f94 z3v134) z3v133) + (= (z3f95 z3v134) z3v131) + (= z3v134 z3v135) + (= (smt_set_cap (z3f70 (z3f94 z3v134)) + (z3f70 (z3f95 z3v134))) smt_set_emp) + (= (smt_set_cap (z3f70 (z3f94 z3v135)) + (z3f70 (z3f95 z3v135))) smt_set_emp) + (= z3v272 z3v133) + (= (z3f72 z3v272) smt_set_emp) + (= (z3f81 z3v80) z3v80) + (= (z3f81 z3v82) z3v82) + (= (z3f81 z3v83) z3v83) + )) + +(check-sat) diff --git a/test/regress/regress1/sets/UniqueZipper.hs.1030minimized2.cvc4.smt2 b/test/regress/regress1/sets/UniqueZipper.hs.1030minimized2.cvc4.smt2 new file mode 100644 index 000000000..e282e446e --- /dev/null +++ b/test/regress/regress1/sets/UniqueZipper.hs.1030minimized2.cvc4.smt2 @@ -0,0 +1,202 @@ +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) + +(declare-fun z3f70 (Int) mySet) +(declare-fun z3f72 (Int) mySet) +(declare-fun z3f76 (Int) Bool) +(declare-fun z3f77 (Int Int) Int) +(declare-fun z3v78 () Int) +(declare-fun z3f79 (Int) Bool) +(declare-fun z3v80 () Int) +(declare-fun z3f81 (Int) Int) +(declare-fun z3v82 () Int) +(declare-fun z3v83 () Int) +(declare-fun z3v85 () Int) +(declare-fun z3v86 () Int) +(declare-fun z3v87 () Int) +(declare-fun z3f88 () Int) +(declare-fun z3v89 () Int) +(declare-fun z3v90 () Int) +(declare-fun z3v91 () Int) +(declare-fun z3v92 () Int) +(declare-fun z3v93 () Int) +(declare-fun z3f94 (Int) Int) +(declare-fun z3f95 (Int) Int) +(declare-fun z3f96 (Int Int Int) Int) +(declare-fun z3v97 () Int) +(declare-fun z3v98 () Int) +(declare-fun z3v99 () Int) +(declare-fun z3v100 () Int) +(declare-fun z3v101 () Int) +(declare-fun z3v102 () Int) +(declare-fun z3v103 () Int) +(declare-fun z3v104 () Int) +(declare-fun z3v105 () Int) +(declare-fun z3v106 () Int) +(declare-fun z3v107 () Int) +(declare-fun z3v108 () Int) +(declare-fun z3v109 () Int) +(declare-fun z3v110 () Int) +(declare-fun z3v113 () Int) +(declare-fun z3v114 () Int) +(declare-fun z3v115 () Int) +(declare-fun z3v116 () Int) +(declare-fun z3v117 () Int) +(declare-fun z3v118 () Int) +(declare-fun z3v120 () Int) +(declare-fun z3v121 () Int) +(declare-fun z3v122 () Int) +(declare-fun z3v124 () Int) +(declare-fun z3v125 () Int) +(declare-fun z3v126 () Int) +(declare-fun z3v127 () Int) +(declare-fun z3v128 () Int) +(declare-fun z3v129 () Int) +(declare-fun z3v131 () Int) +(declare-fun z3v132 () Int) +(declare-fun z3v133 () Int) +(declare-fun z3v134 () Int) +(declare-fun z3v135 () Int) +(declare-fun z3v136 () Int) +(declare-fun z3v137 () Int) +(declare-fun z3v138 () Int) +(declare-fun z3v139 () Int) +(declare-fun z3v140 () Int) +(declare-fun z3v141 () Int) +(declare-fun z3v142 () Int) +(declare-fun z3v144 () Int) +(declare-fun z3v145 () Int) +(declare-fun z3v146 () Int) +(declare-fun z3v149 () Int) +(declare-fun z3v151 () Int) +(declare-fun z3v154 () Int) +(declare-fun z3v155 () Int) +(declare-fun z3v156 () Int) +(declare-fun z3v157 () Int) +(declare-fun z3v158 () Int) +(declare-fun z3v159 () Int) +(declare-fun z3v161 () Int) +(declare-fun z3v163 () Int) +(declare-fun z3v164 () Int) +(declare-fun z3v165 () Int) +(declare-fun z3v167 () Int) +(declare-fun z3v170 () Int) +(declare-fun z3v174 () Int) +(declare-fun z3v175 () Int) +(declare-fun z3v176 () Int) +(declare-fun z3v179 () Int) +(declare-fun z3v181 () Int) +(declare-fun z3v182 () Int) +(declare-fun z3v183 () Int) +(declare-fun z3v184 () Int) +(declare-fun z3v187 () Int) +(declare-fun z3v188 () Int) +(declare-fun z3v189 () Int) +(declare-fun z3v190 () Int) +(declare-fun z3f191 (Int) Int) +(declare-fun z3f192 (Int) Int) +(declare-fun z3v195 () Int) +(declare-fun z3v196 () Int) +(declare-fun z3v199 () Int) +(declare-fun z3v200 () Int) +(declare-fun z3v201 () Int) +(declare-fun z3v202 () Int) +(declare-fun z3v203 () Int) +(declare-fun z3v206 () Int) +(declare-fun z3v207 () Int) +(declare-fun z3v208 () Int) +(declare-fun z3v210 () Int) +(declare-fun z3v211 () Int) +(declare-fun z3v212 () Int) +(declare-fun z3f213 (Int) Bool) +(declare-fun z3f214 (Int) Int) +(declare-fun z3v215 () Int) +(declare-fun z3v216 () Int) +(declare-fun z3v218 () Int) +(declare-fun z3v220 () Int) +(declare-fun z3v221 () Int) +(declare-fun z3v222 () Int) +(declare-fun z3v223 () Int) +(declare-fun z3v224 () Int) +(declare-fun z3v225 () Int) +(declare-fun z3v226 () Int) +(declare-fun z3v227 () Int) +(declare-fun z3v228 () Int) +(declare-fun z3v229 () Int) +(declare-fun z3v230 () Int) +(declare-fun z3v231 () Int) +(declare-fun z3v233 () Int) +(declare-fun z3v236 () Int) +(declare-fun z3v242 () Int) +(declare-fun z3v243 () Int) +(declare-fun z3v244 () Int) +(declare-fun z3v245 () Int) +(declare-fun z3v247 () Int) +(declare-fun z3v248 () Int) +(declare-fun z3v249 () Int) +(declare-fun z3v250 () Int) +(declare-fun z3v251 () Int) +(declare-fun z3v252 () Int) +(declare-fun z3v253 () Int) +(declare-fun z3v255 () Int) +(declare-fun z3v256 () Int) +(declare-fun z3v258 () Int) +(declare-fun z3v259 () Int) +(declare-fun z3v261 () Int) +(declare-fun z3v262 () Int) +(declare-fun z3v263 () Int) +(declare-fun z3v264 () Int) +(declare-fun z3v266 () Int) +(declare-fun z3v268 () Int) +(declare-fun z3v270 () Int) +(declare-fun z3v271 () Int) +(declare-fun z3v272 () Int) + + +(declare-fun z3v66 () Int) +(declare-fun z3v67 () Int) +(assert (distinct z3v66 z3v67)) +(assert (not (smt_set_mem z3v132 (z3f70 z3v131)))) +(assert (= (z3f72 z3v131) smt_set_emp)) +(assert (= (z3f72 z3v242) + (ite (smt_set_mem z3v271 (z3f70 z3v270)) + (smt_set_cup (smt_set_add smt_set_emp z3v271) + (z3f72 z3v270)) + (z3f72 z3v270)))) +(assert (= (z3f70 z3v242) + (smt_set_cup (smt_set_add smt_set_emp z3v271) + (z3f70 z3v270)))) +(assert (= z3v242 (z3f77 z3v271 z3v270))) +(assert (= z3v242 z3v243)) +(assert (subset (z3f70 z3v242) + (z3f70 z3v244))) +(assert (= (z3f72 z3v243) smt_set_emp)) +(assert (= (z3f72 z3v244) + (ite (smt_set_mem z3v132 (z3f70 z3v131)) + (smt_set_cup (smt_set_add smt_set_emp z3v132) + (z3f72 z3v131)) + (z3f72 z3v131)))) +(assert (= (z3f70 z3v244) + (smt_set_cup (smt_set_add smt_set_emp z3v132) + (z3f70 z3v131)))) +(assert (= (z3f94 z3v134) z3v133)) +(assert (= (z3f95 z3v134) z3v131)) +(assert (= z3v134 z3v135)) +(assert (= (smt_set_cap (z3f70 (z3f94 z3v135)) + (z3f70 (z3f95 z3v135))) smt_set_emp)) +(assert (= z3v272 z3v133)) +(assert (= (z3f72 z3v272) smt_set_emp)) +(assert (= (z3f81 z3v80) z3v80)) +(assert (= (z3f81 z3v82) z3v82)) +(assert (= (z3f81 z3v83) z3v83)) + +(check-sat) diff --git a/test/regress/regress1/sets/UniqueZipper.hs.fqout.cvc4.10.smt2 b/test/regress/regress1/sets/UniqueZipper.hs.fqout.cvc4.10.smt2 new file mode 100644 index 000000000..10ed4be7c --- /dev/null +++ b/test/regress/regress1/sets/UniqueZipper.hs.fqout.cvc4.10.smt2 @@ -0,0 +1,106 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) +(declare-fun z3v66 () Int) +(declare-fun z3v67 () Int) +(assert (distinct z3v66 z3v67)) +(declare-fun z3v68 () Int) +(declare-fun z3f69 (Int) Int) +(declare-fun z3f70 (Int) mySet) +(declare-fun z3v71 () Int) +(declare-fun z3f72 (Int) mySet) +(declare-fun z3v73 () Int) +(declare-fun z3v74 () Int) +(declare-fun z3v75 () Int) +(declare-fun z3f76 (Int) Bool) +(declare-fun z3f77 (Int Int) Int) +(declare-fun z3v78 () Int) +(declare-fun z3f79 (Int) Bool) +(declare-fun z3v80 () Int) +(declare-fun z3f81 (Int) Int) +(declare-fun z3v82 () Int) +(declare-fun z3v83 () Int) +(declare-fun z3v85 () Int) +(declare-fun z3v86 () Int) +(declare-fun z3v87 () Int) +(declare-fun z3f88 () Int) +(declare-fun z3v89 () Int) +(declare-fun z3v90 () Int) +(declare-fun z3v91 () Int) +(declare-fun z3v92 () Int) +(declare-fun z3v93 () Int) +(declare-fun z3f94 (Int) Int) +(declare-fun z3f95 (Int) Int) +(declare-fun z3f96 (Int Int Int) Int) +(declare-fun z3v97 () Int) +(declare-fun z3v98 () Int) +(declare-fun z3v99 () Int) +(assert (= z3v99 z3v98)) +(assert (and (>= (z3f69 z3v85) 0) + (not (smt_set_mem z3v86 (z3f70 z3v85))) + (= (z3f72 z3v85) smt_set_emp) + (>= (z3f69 z3v87) 0) + (= (z3f72 z3v87) smt_set_emp) + (= (z3f70 z3v87) smt_set_emp) + (= (z3f69 z3v87) 0) + (= (z3f76 z3v87) true) + (= z3v87 z3f88) + (>= (z3f69 z3v87) 0) + (= z3v87 z3v89) + (>= (z3f69 z3v87) 0) + (= (z3f70 z3v87) + (z3f70 z3v90)) + (= (z3f72 z3v87) smt_set_emp) + (>= (z3f69 z3v89) 0) + (= (z3f70 z3v89) + (z3f70 z3v90)) + (= (z3f72 z3v89) smt_set_emp) + (>= (z3f69 z3v90) 0) + (= (z3f72 z3v90) + (ite (smt_set_mem z3v86 (z3f70 z3v85)) + (smt_set_cup (smt_set_add smt_set_emp z3v86) + (z3f72 z3v85)) + (z3f72 z3v85))) + (= (z3f70 z3v90) + (smt_set_cup (smt_set_add smt_set_emp z3v86) + (z3f70 z3v85))) + (= (z3f69 z3v90) + (+ 1 (z3f69 z3v85))) + (= (z3f76 z3v90) false) + (>= (z3f69 z3v91) 0) + (= (z3f72 z3v91) smt_set_emp) + (= (z3f70 z3v91) smt_set_emp) + (= (z3f69 z3v91) 0) + (= (z3f76 z3v91) true) + (= z3v91 z3f88) + (>= (z3f69 z3v91) 0) + (= z3v91 z3v92) + (>= (z3f69 z3v91) 0) + (not (smt_set_mem z3v86 (z3f70 z3v91))) + (= (z3f72 z3v91) smt_set_emp) + (= (z3f94 z3v93) z3v92) + (= (z3f95 z3v93) z3v85) + (= z3v93 (z3f96 z3v86 z3v92 z3v85)) + (= z3v93 z3v97) + (= (smt_set_cap (z3f70 (z3f94 z3v93)) + (z3f70 (z3f95 z3v93))) smt_set_emp) + (>= (z3f69 z3v92) 0) + (not (smt_set_mem z3v86 (z3f70 z3v92))) + (= (z3f72 z3v92) smt_set_emp) + (= (smt_set_cap (z3f70 (z3f94 z3v97)) + (z3f70 (z3f95 z3v97))) smt_set_emp) + (z3f79 z3v66) + (= (z3f81 z3v80) z3v80) + (= (z3f81 z3v82) z3v82) + (not (z3f79 z3v67)) + (= (z3f81 z3v83) z3v83))) +(assert (not (> z3v99 z3v98))) +(check-sat) diff --git a/test/regress/regress1/sets/UniqueZipper.hs.fqout.cvc4.1832.smt2 b/test/regress/regress1/sets/UniqueZipper.hs.fqout.cvc4.1832.smt2 new file mode 100644 index 000000000..6165b98de --- /dev/null +++ b/test/regress/regress1/sets/UniqueZipper.hs.fqout.cvc4.1832.smt2 @@ -0,0 +1,227 @@ +(set-logic QF_ALL_SUPPORTED) +(set-info :status unsat) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2))) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) +(declare-fun z3v66 () Int) +(declare-fun z3v67 () Int) +(assert (distinct z3v66 z3v67)) +(declare-fun z3v68 () Int) +(declare-fun z3f69 (Int) Int) +(declare-fun z3f70 (Int) mySet) +(declare-fun z3v71 () Int) +(declare-fun z3f72 (Int) mySet) +(declare-fun z3v73 () Int) +(declare-fun z3v74 () Int) +(declare-fun z3v75 () Int) +(declare-fun z3f76 (Int) Bool) +(declare-fun z3f77 (Int Int) Int) +(declare-fun z3v78 () Int) +(declare-fun z3f79 (Int) Bool) +(declare-fun z3v80 () Int) +(declare-fun z3f81 (Int) Int) +(declare-fun z3v82 () Int) +(declare-fun z3v83 () Int) +(declare-fun z3v85 () Int) +(declare-fun z3v86 () Int) +(declare-fun z3v87 () Int) +(declare-fun z3f88 () Int) +(declare-fun z3v89 () Int) +(declare-fun z3v90 () Int) +(declare-fun z3v91 () Int) +(declare-fun z3v92 () Int) +(declare-fun z3v93 () Int) +(declare-fun z3f94 (Int) Int) +(declare-fun z3f95 (Int) Int) +(declare-fun z3f96 (Int Int Int) Int) +(declare-fun z3v97 () Int) +(declare-fun z3v98 () Int) +(declare-fun z3v99 () Int) +(declare-fun z3v100 () Int) +(declare-fun z3v101 () Int) +(declare-fun z3v102 () Int) +(declare-fun z3v103 () Int) +(declare-fun z3v104 () Int) +(declare-fun z3v105 () Int) +(declare-fun z3v106 () Int) +(declare-fun z3v107 () Int) +(declare-fun z3v108 () Int) +(declare-fun z3v109 () Int) +(declare-fun z3v110 () Int) +(declare-fun z3v113 () Int) +(declare-fun z3v114 () Int) +(declare-fun z3v115 () Int) +(declare-fun z3v116 () Int) +(declare-fun z3v117 () Int) +(declare-fun z3v118 () Int) +(declare-fun z3v120 () Int) +(declare-fun z3v121 () Int) +(declare-fun z3v122 () Int) +(declare-fun z3v124 () Int) +(declare-fun z3v125 () Int) +(declare-fun z3v126 () Int) +(declare-fun z3v127 () Int) +(declare-fun z3v128 () Int) +(declare-fun z3v129 () Int) +(declare-fun z3v131 () Int) +(declare-fun z3v132 () Int) +(declare-fun z3v133 () Int) +(declare-fun z3v134 () Int) +(declare-fun z3v135 () Int) +(declare-fun z3v136 () Int) +(declare-fun z3v137 () Int) +(declare-fun z3v138 () Int) +(declare-fun z3v139 () Int) +(declare-fun z3v140 () Int) +(declare-fun z3v141 () Int) +(declare-fun z3v142 () Int) +(declare-fun z3v144 () Int) +(declare-fun z3v145 () Int) +(declare-fun z3v146 () Int) +(declare-fun z3v149 () Int) +(declare-fun z3v151 () Int) +(declare-fun z3v154 () Int) +(declare-fun z3v155 () Int) +(declare-fun z3v156 () Int) +(declare-fun z3v157 () Int) +(declare-fun z3v158 () Int) +(declare-fun z3v159 () Int) +(declare-fun z3v161 () Int) +(declare-fun z3v163 () Int) +(declare-fun z3v164 () Int) +(declare-fun z3v165 () Int) +(declare-fun z3v167 () Int) +(declare-fun z3v170 () Int) +(declare-fun z3v174 () Int) +(declare-fun z3v175 () Int) +(declare-fun z3v176 () Int) +(declare-fun z3v179 () Int) +(declare-fun z3v181 () Int) +(declare-fun z3v182 () Int) +(declare-fun z3v183 () Int) +(declare-fun z3v184 () Int) +(declare-fun z3v187 () Int) +(declare-fun z3v188 () Int) +(declare-fun z3v189 () Int) +(declare-fun z3v190 () Int) +(declare-fun z3f191 (Int) Int) +(declare-fun z3f192 (Int) Int) +(declare-fun z3v195 () Int) +(declare-fun z3v196 () Int) +(declare-fun z3v199 () Int) +(declare-fun z3v200 () Int) +(declare-fun z3v201 () Int) +(declare-fun z3v202 () Int) +(declare-fun z3v203 () Int) +(declare-fun z3v206 () Int) +(declare-fun z3v207 () Int) +(declare-fun z3v208 () Int) +(declare-fun z3v210 () Int) +(declare-fun z3v211 () Int) +(declare-fun z3v212 () Int) +(declare-fun z3f213 (Int) Bool) +(declare-fun z3f214 (Int) Int) +(declare-fun z3v215 () Int) +(declare-fun z3v216 () Int) +(declare-fun z3v218 () Int) +(declare-fun z3v220 () Int) +(declare-fun z3v221 () Int) +(declare-fun z3v222 () Int) +(declare-fun z3v223 () Int) +(declare-fun z3v224 () Int) +(declare-fun z3v225 () Int) +(declare-fun z3v226 () Int) +(declare-fun z3v227 () Int) +(declare-fun z3v228 () Int) +(declare-fun z3v229 () Int) +(declare-fun z3v230 () Int) +(declare-fun z3v231 () Int) +(declare-fun z3v233 () Int) +(declare-fun z3v236 () Int) +(declare-fun z3v242 () Int) +(declare-fun z3v243 () Int) +(declare-fun z3v244 () Int) +(declare-fun z3v245 () Int) +(declare-fun z3v247 () Int) +(declare-fun z3v248 () Int) +(declare-fun z3v249 () Int) +(declare-fun z3v250 () Int) +(declare-fun z3v251 () Int) +(declare-fun z3v252 () Int) +(declare-fun z3v253 () Int) +(declare-fun z3v255 () Int) +(declare-fun z3v256 () Int) +(declare-fun z3v258 () Int) +(declare-fun z3v259 () Int) +(declare-fun z3v261 () Int) +(declare-fun z3v262 () Int) +(declare-fun z3v263 () Int) +(declare-fun z3v264 () Int) +(declare-fun z3v266 () Int) +(declare-fun z3v268 () Int) +(declare-fun z3v270 () Int) +(declare-fun z3v271 () Int) +(declare-fun z3v272 () Int) +(declare-fun z3v274 () Int) +(declare-fun z3v275 () Int) +(declare-fun z3v276 () Int) +(declare-fun z3v278 () Int) +(declare-fun z3v279 () Int) +(declare-fun z3v281 () Int) +(declare-fun z3v282 () Int) +(declare-fun z3v283 () Int) +(declare-fun z3v284 () Int) +(declare-fun z3v285 () Int) +(declare-fun z3v287 () Int) +(declare-fun z3v289 () Int) +(declare-fun z3v290 () Int) +(declare-fun z3v291 () Int) +(declare-fun z3v292 () Int) +(declare-fun z3v293 () Int) +(declare-fun z3v296 () Int) +(declare-fun z3v298 () Int) +(declare-fun z3v299 () Int) +(declare-fun z3f300 (Int Int) Int) +(declare-fun z3v301 () Int) +(declare-fun z3v302 () Int) +(declare-fun z3v303 () Int) +(declare-fun z3v304 () Int) +(declare-fun z3v308 () Int) +(declare-fun z3v309 () Int) +(declare-fun z3v310 () Int) +(declare-fun z3v314 () Int) +(declare-fun z3v315 () Int) +(declare-fun z3v316 () Int) +(declare-fun z3v317 () Int) +(declare-fun z3v318 () Int) +(declare-fun z3v319 () Int) +(declare-fun z3v320 () Int) +(declare-fun z3v324 () Int) +(declare-fun z3v325 () Int) +(declare-fun z3v326 () Int) +(declare-fun z3v327 () Int) +(declare-fun z3v328 () Int) +(declare-fun z3v330 () Int) +(declare-fun z3v332 () Int) +(declare-fun z3v333 () Int) +(declare-fun z3v334 () Int) +(declare-fun z3v335 () Int) +(declare-fun z3v336 () Int) +(declare-fun z3v337 () Int) +(declare-fun z3v339 () Int) +(declare-fun z3v340 () Int) +(declare-fun z3v341 () Int) +(declare-fun z3v342 () Int) +(assert (= z3v342 z3v113)) +(assert (>= (z3f69 z3v342) 0)) +(assert (and (>= (z3f69 z3v113) 0) (>= (z3f69 z3v114) 0) (= (z3f72 z3v114) smt_set_emp) (= (z3f70 z3v114) smt_set_emp) (= (z3f69 z3v114) 0) (= (z3f76 z3v114) true) (>= (z3f69 z3v115) 0) (= (z3f72 z3v115) (ite (smt_set_mem z3v116 (z3f70 z3v113)) (smt_set_cup (smt_set_add smt_set_emp z3v116) (z3f72 z3v113)) (z3f72 z3v113))) (= (z3f70 z3v115) (smt_set_cup (smt_set_add smt_set_emp z3v116) (z3f70 z3v113))) (= (z3f69 z3v115) (+ 1 (z3f69 z3v113))) (= (z3f76 z3v115) false) (= z3v115 (z3f77 z3v116 z3v113)) (>= (z3f69 z3v115) 0) (= z3v115 z3v117) (>= (z3f69 z3v115) 0) (= (z3f72 z3v115) smt_set_emp) (>= (z3f69 z3v117) 0) (= (z3f72 z3v117) smt_set_emp) (z3f79 z3v66) (= (z3f81 z3v80) z3v80) (= (z3f81 z3v82) z3v82) (not (z3f79 z3v67)) (= (z3f81 z3v83) z3v83))) +(assert (not (and (= (z3f72 z3v342) smt_set_emp) (not (smt_set_mem z3v116 (z3f70 z3v342)))))) +(check-sat) diff --git a/test/regress/regress1/sets/arjun-set-univ.cvc b/test/regress/regress1/sets/arjun-set-univ.cvc new file mode 100644 index 000000000..3c35a62a5 --- /dev/null +++ b/test/regress/regress1/sets/arjun-set-univ.cvc @@ -0,0 +1,8 @@ +% EXPECT: Extended set operators are not supported in default mode, try --sets-ext. +% EXIT: 1 +OPTION "produce-models" true; +x,y,z : SET OF BOOLEAN; +ASSERT x = {TRUE}; +ASSERT y = {FALSE}; +CHECKSAT z = ~ y; +COUNTERMODEL; diff --git a/test/regress/regress1/sets/card-3.smt2 b/test/regress/regress1/sets/card-3.smt2 new file mode 100644 index 000000000..0e96b0231 --- /dev/null +++ b/test/regress/regress1/sets/card-3.smt2 @@ -0,0 +1,12 @@ +(set-logic QF_UFLIAFS) +(set-info :status unsat) +(declare-sort E 0) +(declare-fun s () (Set E)) +(declare-fun t () (Set E)) +(declare-fun u () (Set E)) +(assert (>= (card (union s t)) 8)) +(assert (>= (card (union s u)) 8)) +(assert (<= (card (union t u)) 5)) +(assert (<= (card s) 5)) +(assert (= (as emptyset (Set E)) (intersection t u))) +(check-sat) diff --git a/test/regress/regress1/sets/card-4.smt2 b/test/regress/regress1/sets/card-4.smt2 new file mode 100644 index 000000000..456e24ca7 --- /dev/null +++ b/test/regress/regress1/sets/card-4.smt2 @@ -0,0 +1,24 @@ +(set-logic QF_UFLIAFS) +(set-info :status sat) +(declare-sort E 0) +(declare-fun s () (Set E)) +(declare-fun t () (Set E)) +(declare-fun u () (Set E)) +(assert (>= (card (union s t)) 8)) +(assert (>= (card (union s u)) 8)) +;(assert (<= (card (union t u)) 5)) +(assert (<= (card s) 5)) +(assert (= (as emptyset (Set E)) (intersection t u))) +(declare-fun x1 () E) +(declare-fun x2 () E) +(declare-fun x3 () E) +(declare-fun x4 () E) +(declare-fun x5 () E) +(declare-fun x6 () E) +(assert (member x1 s)) +(assert (member x2 s)) +(assert (member x3 s)) +(assert (member x4 s)) +(assert (member x5 s)) +(assert (member x6 s)) +(check-sat) diff --git a/test/regress/regress1/sets/card-5.smt2 b/test/regress/regress1/sets/card-5.smt2 new file mode 100644 index 000000000..4135a0c16 --- /dev/null +++ b/test/regress/regress1/sets/card-5.smt2 @@ -0,0 +1,25 @@ +(set-logic QF_UFLIAFS) +(set-info :status unsat) +(declare-sort E 0) +(declare-fun s () (Set E)) +(declare-fun t () (Set E)) +(declare-fun u () (Set E)) +(assert (>= (card (union s t)) 8)) +(assert (>= (card (union s u)) 8)) +;(assert (<= (card (union t u)) 5)) +(assert (<= (card s) 5)) +(assert (= (as emptyset (Set E)) (intersection t u))) +(declare-fun x1 () E) +(declare-fun x2 () E) +(declare-fun x3 () E) +(declare-fun x4 () E) +(declare-fun x5 () E) +(declare-fun x6 () E) +(assert (member x1 s)) +(assert (member x2 s)) +(assert (member x3 s)) +(assert (member x4 s)) +(assert (member x5 s)) +(assert (member x6 s)) +(assert (distinct x1 x2 x3 x4 x5 x6)) +(check-sat) diff --git a/test/regress/regress1/sets/card-6.smt2 b/test/regress/regress1/sets/card-6.smt2 new file mode 100644 index 000000000..87d87c03b --- /dev/null +++ b/test/regress/regress1/sets/card-6.smt2 @@ -0,0 +1,17 @@ +(set-logic QF_UFLIAFS) +(set-info :status unsat) +(declare-sort E 0) +(declare-fun A () (Set E)) +(declare-fun B () (Set E)) +(declare-fun C () (Set E)) +(assert + (and + (= (as emptyset (Set E)) + (intersection A B)) + (subset C (union A B)) + (>= (card C) 5) + (<= (card A) 2) + (<= (card B) 2) + ) +) +(check-sat) diff --git a/test/regress/regress1/sets/card-7.smt2 b/test/regress/regress1/sets/card-7.smt2 new file mode 100644 index 000000000..df1867c63 --- /dev/null +++ b/test/regress/regress1/sets/card-7.smt2 @@ -0,0 +1,47 @@ +(set-logic QF_UFLIAFS) +(set-info :status sat) +(declare-sort E 0) +(declare-fun A1 () (Set E)) +(declare-fun A2 () (Set E)) +(declare-fun A3 () (Set E)) +(declare-fun A4 () (Set E)) +(declare-fun A5 () (Set E)) +(declare-fun A6 () (Set E)) +(declare-fun A7 () (Set E)) +(declare-fun A8 () (Set E)) +(declare-fun A9 () (Set E)) +(declare-fun A10 () (Set E)) +(declare-fun A11 () (Set E)) +(declare-fun A12 () (Set E)) +(declare-fun A13 () (Set E)) +(declare-fun A14 () (Set E)) +(declare-fun A15 () (Set E)) +(declare-fun A16 () (Set E)) +(declare-fun A17 () (Set E)) +(declare-fun A18 () (Set E)) +(declare-fun A19 () (Set E)) +(declare-fun A20 () (Set E)) +(assert (and + (= (card A1) 1) + (= (card A2) 1) + (= (card A3) 1) + (= (card A4) 1) + (= (card A5) 1) + (= (card A6) 1) + (= (card A7) 1) + (= (card A8) 1) + (= (card A9) 1) + (= (card A10) 1) + (= (card A11) 1) + (= (card A12) 1) + (= (card A13) 1) + (= (card A14) 1) + (= (card A15) 1) + (= (card A16) 1) + (= (card A17) 1) + (= (card A18) 1) + (= (card A19) 1) + (= (card A20) 1) +)) +(assert (= 20 (+ (card A1) (card A2) (card A3) (card A4) (card A5) (card A6) (card A7) (card A8) (card A9) (card A10) (card A11) (card A12) (card A13) (card A14) (card A15) (card A16) (card A17) (card A18) (card A19) (card A20)))) +(check-sat) diff --git a/test/regress/regress1/sets/copy_check_heap_access_33_4.smt2 b/test/regress/regress1/sets/copy_check_heap_access_33_4.smt2 new file mode 100644 index 000000000..9af45c2dd --- /dev/null +++ b/test/regress/regress1/sets/copy_check_heap_access_33_4.smt2 @@ -0,0 +1,135 @@ +; COMMAND-LINE: --full-saturate-quant +; EXPECT: unsat +(set-option :print-success false) +(set-logic AUFLIAFS) +(set-info :status unsat) +(declare-sort Loc 0) +(define-sort SetLoc () (Set Loc)) +(define-sort SetInt () (Set Int)) +(declare-sort FldLoc 0) +(declare-sort FldInt 0) +(declare-fun null$0 () Loc) +(declare-fun read$0 (FldInt Loc) Int) +(declare-fun read$1 (FldLoc Loc) Loc) +(declare-fun Btwn$0 (FldLoc Loc Loc Loc) Bool) +(declare-fun Alloc$0 () SetLoc) +(declare-fun Alloc_1$0 () SetLoc) +(declare-fun Axiom_1$0 () Bool) +(declare-fun FP$0 () SetLoc) +(declare-fun FP_1$0 () SetLoc) +(declare-fun FP_Caller$0 () SetLoc) +(declare-fun FP_Caller_1$0 () SetLoc) +(declare-fun cp_2$0 () Loc) +(declare-fun curr_2$0 () Loc) +(declare-fun data$0 () FldInt) +(declare-fun lst$0 () Loc) +(declare-fun next$0 () FldLoc) +(declare-fun res_1$0 () Loc) +(declare-fun sk_?X_4$0 () SetLoc) +(declare-fun slseg_domain$0 (FldInt FldLoc Loc Loc) SetLoc) +(declare-fun slseg_struct$0 (SetLoc FldInt FldLoc Loc Loc) Bool) +(declare-fun tmp_2$0 () Loc) + +(assert (! (forall ((?y Loc)) + (or (not (Btwn$0 next$0 null$0 ?y ?y)) (= null$0 ?y) + (Btwn$0 next$0 null$0 (read$1 next$0 null$0) ?y))) + :named btwn_reach_1)) + +(assert (! (forall ((?y Loc)) + (or (not (= (read$1 next$0 null$0) null$0)) + (not (Btwn$0 next$0 null$0 ?y ?y)) (= null$0 ?y))) + :named btwn_cycl_1)) + +(assert (! (Btwn$0 next$0 null$0 (read$1 next$0 null$0) (read$1 next$0 null$0)) + :named btwn_step_1)) + +(assert (! (forall ((l1 Loc) (l2 Loc)) + (or (not Axiom_1$0) + (or (<= (read$0 data$0 l1) (read$0 data$0 l2)) + (not (Btwn$0 next$0 l1 l2 null$0)) (not (member l1 sk_?X_4$0)) + (not (member l2 sk_?X_4$0))))) + :named sortedness_3)) + +(assert (! (= (read$1 next$0 null$0) null$0) :named read_null_1)) + +(assert (! (not (member tmp_2$0 Alloc$0)) :named new_31_11)) + +(assert (! (not (member null$0 Alloc$0)) :named initial_footprint_of_copy_23_11_2)) + +(assert (! (not (= lst$0 null$0)) :named if_else_26_6)) + +(assert (! (= FP_Caller$0 (union FP$0 FP_Caller$0)) + :named precondition_of_copy_23_11_4)) + +(assert (! (= sk_?X_4$0 FP$0) :named precondition_of_copy_23_11_5)) + +(assert (! (= res_1$0 tmp_2$0) :named assign_31_4)) + +(assert (! (= cp_2$0 res_1$0) :named assign_32_4)) + +(assert (! (= FP_1$0 (union FP$0 (singleton tmp_2$0))) :named assign_31_11)) + +(assert (! (or (and (Btwn$0 next$0 lst$0 null$0 null$0) Axiom_1$0) + (not (slseg_struct$0 sk_?X_4$0 data$0 next$0 lst$0 null$0))) + :named unnamed_3)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 lst$0 l1 null$0) + (member l1 (slseg_domain$0 data$0 next$0 lst$0 null$0)) + (not (= l1 null$0))) + (and (or (= l1 null$0) (not (Btwn$0 next$0 lst$0 l1 null$0))) + (not (member l1 (slseg_domain$0 data$0 next$0 lst$0 null$0)))))) + :named slseg_footprint_2)) + +(assert (! (not (member curr_2$0 FP_1$0)) :named check_heap_access_33_4)) + +(assert (! (not (= tmp_2$0 null$0)) :named new_31_11_1)) + +(assert (! (slseg_struct$0 sk_?X_4$0 data$0 next$0 lst$0 null$0) + :named precondition_of_copy_23_11_6)) + +(assert (! (= sk_?X_4$0 (slseg_domain$0 data$0 next$0 lst$0 null$0)) + :named precondition_of_copy_23_11_7)) + +(assert (! (= Alloc$0 (union FP_Caller$0 Alloc$0)) + :named initial_footprint_of_copy_23_11_3)) + +(assert (! (= curr_2$0 lst$0) :named assign_30_4)) + +(assert (! (= FP_Caller_1$0 (setminus FP_Caller$0 FP$0)) :named assign_26_2_1)) + +(assert (! (= Alloc_1$0 (union Alloc$0 (singleton tmp_2$0))) :named assign_31_11_1)) + +(assert (! (forall ((?x Loc)) (Btwn$0 next$0 ?x ?x ?x)) :named btwn_refl_1)) + +(assert (! (forall ((?x Loc) (?y Loc)) (or (not (Btwn$0 next$0 ?x ?y ?x)) (= ?x ?y))) + :named btwn_sndw_1)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?y)) (not (Btwn$0 next$0 ?x ?z ?z)) + (Btwn$0 next$0 ?x ?y ?z) (Btwn$0 next$0 ?x ?z ?y))) + :named btwn_ord1_1)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) + (and (Btwn$0 next$0 ?x ?y ?y) (Btwn$0 next$0 ?y ?z ?z)))) + :named btwn_ord2_1)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?y)) (not (Btwn$0 next$0 ?y ?z ?z)) + (Btwn$0 next$0 ?x ?z ?z))) + :named btwn_trn1_1)) + +(assert (! (forall ((?u Loc) (?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) (not (Btwn$0 next$0 ?y ?u ?z)) + (and (Btwn$0 next$0 ?x ?y ?u) (Btwn$0 next$0 ?x ?u ?z)))) + :named btwn_trn2_1)) + +(assert (! (forall ((?u Loc) (?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) (not (Btwn$0 next$0 ?x ?u ?y)) + (and (Btwn$0 next$0 ?x ?u ?z) (Btwn$0 next$0 ?u ?y ?z)))) + :named btwn_trn3_1)) + +(check-sat) +(exit) diff --git a/test/regress/regress1/sets/deepmeas0.hs.fqout.cvc4.41.smt2 b/test/regress/regress1/sets/deepmeas0.hs.fqout.cvc4.41.smt2 new file mode 100644 index 000000000..83dfe41e5 --- /dev/null +++ b/test/regress/regress1/sets/deepmeas0.hs.fqout.cvc4.41.smt2 @@ -0,0 +1,58 @@ +; EXPECT: sat +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2))) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) +(declare-fun z3v58 () Int) +(declare-fun z3v59 () Int) +(assert (distinct z3v58 z3v59)) +(declare-fun z3f60 (Int) Bool) +(declare-fun z3v61 () Int) +(declare-fun z3f62 (Int) Int) +(declare-fun z3v63 () Int) +(declare-fun z3v64 () Int) +(declare-fun z3v65 () Int) +(declare-fun z3v66 () Int) +(declare-fun z3f67 (Int) mySet) +(declare-fun z3v69 () Int) +(declare-fun z3f70 (Int) Int) +(declare-fun z3v76 () Int) +(declare-fun z3v77 () Int) +(declare-fun z3v78 () Int) +(declare-fun z3v79 () Int) +(declare-fun z3v80 () Int) +(declare-fun z3v81 () Int) +(declare-fun z3v82 () Int) +(declare-fun z3f83 (Int) Int) +(declare-fun z3f84 (Int) Int) +(declare-fun z3v85 () Int) +(declare-fun z3f86 (Int) Int) +(declare-fun z3f87 (Int Int) Int) +(declare-fun z3v88 () Int) +(declare-fun z3v89 () Int) +(declare-fun z3f90 (Int) mySet) +(declare-fun z3f91 (Int) Bool) +(declare-fun z3f92 (Int Int) Int) +(declare-fun z3v93 () Int) +(declare-fun z3v94 () Int) +(declare-fun z3v95 () Int) +(declare-fun z3v96 () Int) +(declare-fun z3v97 () Int) +(assert (and (not (z3f60 z3v79)) (not (z3f60 z3v79)) (= z3v79 z3v80) (= (z3f60 z3v79) (= z3v76 z3v81)) (= (z3f60 z3v80) (= z3v76 z3v81)) (= (z3f83 z3v82) z3v81) (= (z3f84 z3v82) z3v81) (= (z3f86 z3v82) z3v85) (= z3v82 (z3f87 z3v81 z3v85)) (= z3v82 z3v88) (>= (z3f70 z3v78) 0) (= (z3f67 z3v78) (smt_set_cup (smt_set_add smt_set_emp (z3f83 z3v88)) (z3f67 z3v89))) (= (z3f90 z3v78) (smt_set_cup (smt_set_add smt_set_emp z3v88) (z3f90 z3v89))) (= (z3f70 z3v78) (+ 1 (z3f70 z3v89))) (= (z3f91 z3v78) false) (= z3v78 (z3f92 z3v88 z3v89)) (>= (z3f70 z3v78) 0) (= z3v78 z3v77) (>= (z3f70 z3v78) 0) (>= (z3f70 z3v89) 0) (>= (z3f70 z3v77) 0) (>= (z3f70 z3v97) 0) (= z3v97 z3v89) (>= (z3f70 z3v97) 0) (z3f60 z3v58) (= (z3f62 z3v61) z3v61) (= (z3f62 z3v63) z3v63) (not (z3f60 z3v59)) (= (z3f62 z3v64) z3v64))) +(assert (smt_set_mem z3v76 (z3f67 z3v78))) +(assert (<= z3v95 z3v93)) +(assert (>= z3v95 z3v93)) +(assert (= z3v95 z3v93)) +(assert (smt_set_mem z3v76 (z3f67 z3v77))) +(declare-fun z3v98 () Int) +(assert (not (< z3v98 z3v85))) +(check-sat) diff --git a/test/regress/regress1/sets/fuzz14418.smt2 b/test/regress/regress1/sets/fuzz14418.smt2 new file mode 100644 index 000000000..24679749c --- /dev/null +++ b/test/regress/regress1/sets/fuzz14418.smt2 @@ -0,0 +1,171 @@ +; symptom: assertion failure in EqEngine : hasTerm(t) +; +; issue: had some nodes in d_pending, even though sat context had been popped, +; and those were no longer relevant. +; +; fix: make pending queues sat context depending. d_pendingEverInserted which +; is still user-context dependent takes care of not generating a lemma twice. +; +; sat +(set-info :source |fuzzsmt|) +(set-info :smt-lib-version 2.0) +(set-info :category "random") +(set-info :status sat) +(set-logic QF_UFLIAFS) +(define-sort Element () Int) +(declare-fun f0 ( Int) Int) +(declare-fun f1 ( (Set Element) (Set Element) (Set Element)) (Set Element)) +(declare-fun p0 ( Int Int) Bool) +(declare-fun p1 ( (Set Element)) Bool) +(declare-fun v0 () Int) +(declare-fun v1 () (Set Element)) +(declare-fun v2 () (Set Element)) +(declare-fun v3 () (Set Element)) +(declare-fun v4 () (Set Element)) +(assert (let ((e5 7)) +(let ((e6 (* e5 v0))) +(let ((e7 (* v0 e5))) +(let ((e8 (f0 e6))) +(let ((e9 (* v0 (- e5)))) +(let ((e10 (f0 v0))) +(let ((e11 (* (- e5) e10))) +(let ((e12 (ite (p0 e7 e6) 1 0))) +(let ((e13 (union v3 v4))) +(let ((e14 (setminus v2 v2))) +(let ((e15 (f1 v1 v4 v1))) +(let ((e16 (f1 e14 v1 v4))) +(let ((e17 (intersection e16 e15))) +(let ((e18 (f1 v4 e15 v2))) +(let ((e19 (ite (p1 e13) (singleton 1) (singleton 0)))) +(let ((e20 (member v0 e17))) +(let ((e21 (member e7 e16))) +(let ((e22 (member e10 e16))) +(let ((e23 (member e8 e17))) +(let ((e24 (member e9 e14))) +(let ((e25 (member e8 e16))) +(let ((e26 (member v0 e13))) +(let ((e27 (member e12 v4))) +(let ((e28 (member e8 e14))) +(let ((e29 (member e8 v1))) +(let ((e30 (member e10 e13))) +(let ((e31 (member e7 e13))) +(let ((e32 (f1 e13 e13 e13))) +(let ((e33 (f1 e18 v4 e17))) +(let ((e34 (f1 v2 v2 e15))) +(let ((e35 (f1 e33 e18 e15))) +(let ((e36 (f1 e19 e14 e17))) +(let ((e37 (f1 e34 e18 e34))) +(let ((e38 (f1 v3 e34 e18))) +(let ((e39 (f1 e16 v4 e13))) +(let ((e40 (f1 v1 e34 e15))) +(let ((e41 (< e10 e11))) +(let ((e42 (= e6 e12))) +(let ((e43 (> e6 e11))) +(let ((e44 (< e12 e8))) +(let ((e45 (< e7 e10))) +(let ((e46 (= e11 e12))) +(let ((e47 (= e11 e7))) +(let ((e48 (<= e11 e10))) +(let ((e49 (p0 e9 e9))) +(let ((e50 (>= v0 e10))) +(let ((e51 (ite e22 e14 e33))) +(let ((e52 (ite e45 e16 e37))) +(let ((e53 (ite e42 e39 e17))) +(let ((e54 (ite e21 e39 e33))) +(let ((e55 (ite e29 e13 e13))) +(let ((e56 (ite e48 e15 e34))) +(let ((e57 (ite e50 e38 e53))) +(let ((e58 (ite e47 e32 v1))) +(let ((e59 (ite e20 e36 e33))) +(let ((e60 (ite e28 e35 v2))) +(let ((e61 (ite e48 e40 e38))) +(let ((e62 (ite e30 e38 e53))) +(let ((e63 (ite e22 v4 e19))) +(let ((e64 (ite e46 e60 e53))) +(let ((e65 (ite e25 e61 e16))) +(let ((e66 (ite e23 v3 e38))) +(let ((e67 (ite e49 v4 e18))) +(let ((e68 (ite e21 e54 v3))) +(let ((e69 (ite e25 e15 v4))) +(let ((e70 (ite e20 e55 e19))) +(let ((e71 (ite e27 e38 e36))) +(let ((e72 (ite e28 e14 e33))) +(let ((e73 (ite e42 e66 e60))) +(let ((e74 (ite e26 e54 e69))) +(let ((e75 (ite e28 e68 e71))) +(let ((e76 (ite e24 e33 e52))) +(let ((e77 (ite e44 e40 e74))) +(let ((e78 (ite e48 e32 e51))) +(let ((e79 (ite e22 e34 e62))) +(let ((e80 (ite e22 e78 e73))) +(let ((e81 (ite e22 e13 e55))) +(let ((e82 (ite e43 e37 e70))) +(let ((e83 (ite e48 e59 e80))) +(let ((e84 (ite e29 e15 e77))) +(let ((e85 (ite e41 e19 e35))) +(let ((e86 (ite e22 e63 e69))) +(let ((e87 (ite e26 e19 e70))) +(let ((e88 (ite e46 e37 e53))) +(let ((e89 (ite e25 e70 e76))) +(let ((e90 (ite e31 v4 e73))) +(let ((e91 (ite e46 e12 e8))) +(let ((e92 (ite e43 e11 e6))) +(let ((e93 (ite e50 e10 e7))) +(let ((e94 (ite e21 e8 e7))) +(let ((e95 (ite e27 v0 e6))) +(let ((e96 (ite e24 e9 e92))) +(let ((e97 (ite e22 e6 e92))) +(let ((e98 (ite e49 e96 e12))) +(let ((e99 (ite e27 e98 e6))) +(let ((e100 (ite e31 e11 e8))) +(let ((e101 (ite e26 e12 v0))) +(let ((e102 (ite e22 e92 e96))) +(let ((e103 (ite e28 e92 e6))) +(let ((e104 (ite e27 e12 v0))) +(let ((e105 (ite e23 e101 e9))) +(let ((e106 (ite e47 e11 e104))) +(let ((e107 (ite e45 e105 e100))) +(let ((e108 (ite e48 e12 e9))) +(let ((e109 (ite e42 e96 e91))) +(let ((e110 (ite e29 e11 e101))) +(let ((e111 (ite e50 e107 e110))) +(let ((e112 (ite e29 e104 e92))) +(let ((e113 (ite e20 e108 e12))) +(let ((e114 (ite e44 e96 e104))) +(let ((e115 (ite e41 e105 e110))) +(let ((e116 (ite e41 e6 e103))) +(let ((e117 (ite e28 e92 e114))) +(let ((e118 (ite e30 e111 e113))) +(let ((e119 (ite e30 e109 e8))) +(let ((e120 (ite e25 e12 e118))) +(let ((e121 (xor e46 e42))) +(let ((e122 (xor e28 e29))) +(let ((e123 (= e122 e49))) +(let ((e124 (and e43 e45))) +(let ((e125 (or e121 e23))) +(let ((e126 (and e125 e24))) +(let ((e127 (= e41 e126))) +(let ((e128 (xor e124 e44))) +(let ((e129 (not e26))) +(let ((e130 (= e22 e123))) +(let ((e131 (not e20))) +(let ((e132 (and e127 e27))) +(let ((e133 (=> e50 e131))) +(let ((e134 (=> e132 e30))) +(let ((e135 (xor e128 e48))) +(let ((e136 (ite e129 e47 e129))) +(let ((e137 (and e133 e130))) +(let ((e138 (or e136 e134))) +(let ((e139 (and e31 e31))) +(let ((e140 (not e137))) +(let ((e141 (= e140 e139))) +(let ((e142 (= e25 e21))) +(let ((e143 (not e142))) +(let ((e144 (and e143 e135))) +(let ((e145 (and e144 e138))) +(let ((e146 (and e145 e145))) +(let ((e147 (= e141 e146))) +e147 +)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +(check-sat) diff --git a/test/regress/regress1/sets/fuzz15201.smt2 b/test/regress/regress1/sets/fuzz15201.smt2 new file mode 100644 index 000000000..e12b74d18 --- /dev/null +++ b/test/regress/regress1/sets/fuzz15201.smt2 @@ -0,0 +1,269 @@ +; symptom: unsat instead of sat +; issue/fix: buggy rewriter for setminus +(set-info :source |fuzzsmt|) +(set-info :smt-lib-version 2.0) +(set-info :category "random") +(set-info :status sat) +(set-logic QF_UFLIAFS) +(define-sort Element () Int) +(declare-fun f0 ( Int) Int) +(declare-fun f1 ( (Set Element)) (Set Element)) +(declare-fun p0 ( Int) Bool) +(declare-fun p1 ( (Set Element) (Set Element) (Set Element)) Bool) +(declare-fun v0 () Int) +(declare-fun v1 () (Set Element)) +(declare-fun v2 () (Set Element)) +(assert (let ((e3 0)) +(let ((e4 (+ v0 v0))) +(let ((e5 (+ v0 e4))) +(let ((e6 (* (- e3) e4))) +(let ((e7 (- e4 e6))) +(let ((e8 (+ e7 e5))) +(let ((e9 (- v0))) +(let ((e10 (* e6 e3))) +(let ((e11 (- e8 e5))) +(let ((e12 (- e5))) +(let ((e13 (* e7 (- e3)))) +(let ((e14 (f0 e7))) +(let ((e15 (ite (p0 e9) 1 0))) +(let ((e16 (setminus v2 v1))) +(let ((e17 (setminus v1 v2))) +(let ((e18 (union e17 e17))) +(let ((e19 (intersection e17 v1))) +(let ((e20 (intersection e17 e18))) +(let ((e21 (intersection v1 e16))) +(let ((e22 (setminus e20 e16))) +(let ((e23 (ite (p1 v2 e18 e21) (singleton 1) (singleton 0)))) +(let ((e24 (setminus e17 e23))) +(let ((e25 (union v2 e22))) +(let ((e26 (union e24 e18))) +(let ((e27 (ite (p1 e20 e19 e25) (singleton 1) (singleton 0)))) +(let ((e28 (f1 e20))) +(let ((e29 (member e14 e17))) +(let ((e30 (member e13 e23))) +(let ((e31 (member e11 e25))) +(let ((e32 (member e6 v1))) +(let ((e33 (member e9 v1))) +(let ((e34 (member v0 e28))) +(let ((e35 (member e9 e16))) +(let ((e36 (member e4 e17))) +(let ((e37 (member e9 e18))) +(let ((e38 (member e14 e25))) +(let ((e39 (member e14 v2))) +(let ((e40 (member v0 v1))) +(let ((e41 (member e4 e16))) +(let ((e42 (member e15 e21))) +(let ((e43 (member e7 e22))) +(let ((e44 (member e11 v2))) +(let ((e45 (member e14 e22))) +(let ((e46 (member e11 e16))) +(let ((e47 (member e15 e22))) +(let ((e48 (member e10 e23))) +(let ((e49 (member e4 e21))) +(let ((e50 (member e5 e28))) +(let ((e51 (member e6 e28))) +(let ((e52 (member v0 e22))) +(let ((e53 (member e14 e20))) +(let ((e54 (f1 e21))) +(let ((e55 (f1 e28))) +(let ((e56 (f1 e27))) +(let ((e57 (f1 e17))) +(let ((e58 (f1 e22))) +(let ((e59 (f1 e26))) +(let ((e60 (f1 e19))) +(let ((e61 (f1 v1))) +(let ((e62 (f1 e24))) +(let ((e63 (f1 e20))) +(let ((e64 (f1 e23))) +(let ((e65 (f1 v2))) +(let ((e66 (f1 e25))) +(let ((e67 (f1 e62))) +(let ((e68 (f1 e18))) +(let ((e69 (f1 e18))) +(let ((e70 (f1 e23))) +(let ((e71 (f1 e55))) +(let ((e72 (f1 e26))) +(let ((e73 (f1 e16))) +(let ((e74 (= e13 e13))) +(let ((e75 (p0 e11))) +(let ((e76 (distinct e15 e4))) +(let ((e77 (> e14 e10))) +(let ((e78 (= e4 e15))) +(let ((e79 (distinct v0 e9))) +(let ((e80 (= e15 e14))) +(let ((e81 (>= e10 e11))) +(let ((e82 (distinct e9 e8))) +(let ((e83 (p0 v0))) +(let ((e84 (>= e12 e14))) +(let ((e85 (distinct e7 e13))) +(let ((e86 (<= e6 e11))) +(let ((e87 (= e13 e10))) +(let ((e88 (>= e7 e8))) +(let ((e89 (<= v0 e10))) +(let ((e90 (>= e5 e15))) +(let ((e91 (ite e33 e66 e26))) +(let ((e92 (ite e88 e54 v1))) +(let ((e93 (ite e76 e70 e16))) +(let ((e94 (ite e85 e19 e24))) +(let ((e95 (ite e88 e68 e20))) +(let ((e96 (ite e86 e25 e65))) +(let ((e97 (ite e83 v2 e23))) +(let ((e98 (ite e50 e63 e63))) +(let ((e99 (ite e48 e56 e93))) +(let ((e100 (ite e38 e60 v2))) +(let ((e101 (ite e30 e61 e61))) +(let ((e102 (ite e85 e69 e57))) +(let ((e103 (ite e83 e18 e102))) +(let ((e104 (ite e43 e62 e97))) +(let ((e105 (ite e76 e27 e21))) +(let ((e106 (ite e89 e92 e55))) +(let ((e107 (ite e46 e72 e65))) +(let ((e108 (ite e79 e71 e97))) +(let ((e109 (ite e44 e64 e21))) +(let ((e110 (ite e33 e70 e25))) +(let ((e111 (ite e43 e63 e105))) +(let ((e112 (ite e39 e56 e108))) +(let ((e113 (ite e49 e17 e107))) +(let ((e114 (ite e74 e63 e113))) +(let ((e115 (ite e84 e28 v1))) +(let ((e116 (ite e82 e68 e67))) +(let ((e117 (ite e75 e73 e21))) +(let ((e118 (ite e36 e59 e16))) +(let ((e119 (ite e48 e118 e61))) +(let ((e120 (ite e90 e56 e100))) +(let ((e121 (ite e80 e24 e25))) +(let ((e122 (ite e31 e22 v2))) +(let ((e123 (ite e45 e107 e16))) +(let ((e124 (ite e40 e70 e73))) +(let ((e125 (ite e52 e58 e118))) +(let ((e126 (ite e88 e72 e72))) +(let ((e127 (ite e35 e58 e27))) +(let ((e128 (ite e42 e59 e21))) +(let ((e129 (ite e44 e127 e103))) +(let ((e130 (ite e51 e118 e69))) +(let ((e131 (ite e37 e16 e24))) +(let ((e132 (ite e83 e105 e28))) +(let ((e133 (ite e48 e107 e60))) +(let ((e134 (ite e34 e101 e22))) +(let ((e135 (ite e86 e97 e57))) +(let ((e136 (ite e47 e94 e100))) +(let ((e137 (ite e78 e104 e95))) +(let ((e138 (ite e75 e26 e96))) +(let ((e139 (ite e35 e97 e121))) +(let ((e140 (ite e44 e112 e118))) +(let ((e141 (ite e77 e107 e56))) +(let ((e142 (ite e53 e64 e129))) +(let ((e143 (ite e48 e128 e23))) +(let ((e144 (ite e50 e73 e17))) +(let ((e145 (ite e33 e98 e114))) +(let ((e146 (ite e32 e137 e105))) +(let ((e147 (ite e41 e98 e96))) +(let ((e148 (ite e29 e93 e121))) +(let ((e149 (ite e87 e104 e21))) +(let ((e150 (ite e46 e131 e110))) +(let ((e151 (ite e81 e25 e65))) +(let ((e152 (ite e34 e10 e10))) +(let ((e153 (ite e36 e7 e13))) +(let ((e154 (ite e43 e12 e10))) +(let ((e155 (ite e50 e14 e7))) +(let ((e156 (ite e34 e9 e6))) +(let ((e157 (ite e33 e7 v0))) +(let ((e158 (ite e50 e157 e10))) +(let ((e159 (ite e51 e8 e11))) +(let ((e160 (ite e32 v0 e157))) +(let ((e161 (ite e85 e15 e158))) +(let ((e162 (ite e43 e5 e11))) +(let ((e163 (ite e76 e4 v0))) +(let ((e164 (ite e53 e10 e159))) +(let ((e165 (ite e80 e161 e163))) +(let ((e166 (ite e78 e13 e11))) +(let ((e167 (ite e49 e4 e8))) +(let ((e168 (ite e45 e11 e155))) +(let ((e169 (ite e81 e155 e166))) +(let ((e170 (ite e87 e169 e161))) +(let ((e171 (ite e53 e165 e13))) +(let ((e172 (ite e83 e12 e160))) +(let ((e173 (ite e80 e168 e159))) +(let ((e174 (ite e46 e171 e168))) +(let ((e175 (ite e74 e5 e155))) +(let ((e176 (ite e89 e159 e4))) +(let ((e177 (ite e29 e159 e172))) +(let ((e178 (ite e79 e165 e162))) +(let ((e179 (ite e88 e166 e168))) +(let ((e180 (ite e77 e175 e167))) +(let ((e181 (ite e47 e157 e165))) +(let ((e182 (ite e84 e172 e7))) +(let ((e183 (ite e30 e174 e157))) +(let ((e184 (ite e90 e4 e14))) +(let ((e185 (ite e38 e178 e14))) +(let ((e186 (ite e44 e166 e154))) +(let ((e187 (ite e42 e162 e186))) +(let ((e188 (ite e86 e187 e10))) +(let ((e189 (ite e29 e171 e182))) +(let ((e190 (ite e77 e185 e165))) +(let ((e191 (ite e75 e171 e9))) +(let ((e192 (ite e39 e161 e181))) +(let ((e193 (ite e82 e166 e10))) +(let ((e194 (ite e31 e183 e179))) +(let ((e195 (ite e44 e191 e169))) +(let ((e196 (ite e35 e171 e156))) +(let ((e197 (ite e86 e179 e164))) +(let ((e198 (ite e41 e5 e5))) +(let ((e199 (ite e85 e160 e161))) +(let ((e200 (ite e52 e173 e157))) +(let ((e201 (ite e47 e161 e4))) +(let ((e202 (ite e52 e6 e186))) +(let ((e203 (ite e45 e162 e198))) +(let ((e204 (ite e48 e194 e11))) +(let ((e205 (ite e37 e197 e157))) +(let ((e206 (ite e35 e153 e176))) +(let ((e207 (ite e40 e185 e188))) +(let ((e208 (= e53 e41))) +(let ((e209 (not e79))) +(let ((e210 (= e30 e87))) +(let ((e211 (or e34 e48))) +(let ((e212 (=> e82 e29))) +(let ((e213 (xor e77 e211))) +(let ((e214 (and e31 e78))) +(let ((e215 (ite e36 e76 e37))) +(let ((e216 (= e84 e45))) +(let ((e217 (or e43 e46))) +(let ((e218 (and e88 e40))) +(let ((e219 (not e89))) +(let ((e220 (not e35))) +(let ((e221 (or e218 e213))) +(let ((e222 (xor e216 e75))) +(let ((e223 (ite e85 e90 e219))) +(let ((e224 (= e32 e217))) +(let ((e225 (not e39))) +(let ((e226 (xor e212 e49))) +(let ((e227 (and e222 e81))) +(let ((e228 (or e33 e210))) +(let ((e229 (xor e225 e226))) +(let ((e230 (xor e74 e47))) +(let ((e231 (= e220 e38))) +(let ((e232 (xor e231 e229))) +(let ((e233 (and e50 e221))) +(let ((e234 (and e42 e224))) +(let ((e235 (xor e223 e214))) +(let ((e236 (= e234 e228))) +(let ((e237 (and e227 e235))) +(let ((e238 (not e51))) +(let ((e239 (= e80 e232))) +(let ((e240 (or e230 e86))) +(let ((e241 (not e238))) +(let ((e242 (xor e44 e237))) +(let ((e243 (= e236 e242))) +(let ((e244 (= e209 e240))) +(let ((e245 (and e239 e83))) +(let ((e246 (or e208 e245))) +(let ((e247 (=> e215 e246))) +(let ((e248 (ite e233 e247 e244))) +(let ((e249 (and e248 e241))) +(let ((e250 (=> e243 e249))) +(let ((e251 (and e52 e250))) +e251 +)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +(check-sat) +;(get-model) diff --git a/test/regress/regress1/sets/fuzz31811.smt2 b/test/regress/regress1/sets/fuzz31811.smt2 new file mode 100644 index 000000000..5e7c032ea --- /dev/null +++ b/test/regress/regress1/sets/fuzz31811.smt2 @@ -0,0 +1,187 @@ +; symptom: assertion failure : conflict <=> equality engine inconsistent +; +; issue: the assertion is too strong. what is true is that there is an internal +; conflict <=> equality engine inconsistent. but in case of propagating (dis)equalities +; between shared terms, the some other theory might become inconsistent, and we should +; stop. +; +(set-info :source |fuzzsmt|) +(set-info :smt-lib-version 2.0) +(set-info :category "random") +(set-info :status sat) +(set-logic QF_UFLIAFS) +(define-sort Element () Int) +(declare-fun f0 ( Int Int Int) Int) +(declare-fun f1 ( (Set Element) (Set Element)) (Set Element)) +(declare-fun p0 ( Int Int Int) Bool) +(declare-fun p1 ( (Set Element)) Bool) +(declare-fun v0 () Int) +(declare-fun v1 () (Set Element)) +(declare-fun v2 () (Set Element)) +(declare-fun v3 () (Set Element)) +(declare-fun v4 () (Set Element)) +(assert (let ((e5 2)) +(let ((e6 (+ v0 v0))) +(let ((e7 (* e6 e5))) +(let ((e8 (* e6 (- e5)))) +(let ((e9 (ite (p0 e7 v0 e6) 1 0))) +(let ((e10 (f0 v0 e8 e8))) +(let ((e11 (ite (p1 v1) (singleton 1) (singleton 0)))) +(let ((e12 (union v3 v3))) +(let ((e13 (intersection v3 v1))) +(let ((e14 (ite (p1 v3) (singleton 1) (singleton 0)))) +(let ((e15 (intersection v2 e14))) +(let ((e16 (ite (p1 e11) (singleton 1) (singleton 0)))) +(let ((e17 (ite (p1 v4) (singleton 1) (singleton 0)))) +(let ((e18 (union e15 v2))) +(let ((e19 (ite (p1 e16) (singleton 1) (singleton 0)))) +(let ((e20 (intersection e18 v3))) +(let ((e21 (setminus v4 e12))) +(let ((e22 (union v3 v2))) +(let ((e23 (setminus e12 v4))) +(let ((e24 (setminus v3 e16))) +(let ((e25 (intersection e19 e20))) +(let ((e26 (ite (p1 e15) (singleton 1) (singleton 0)))) +(let ((e27 (setminus e17 e15))) +(let ((e28 (f1 e23 e12))) +(let ((e29 (member e10 e16))) +(let ((e30 (member e10 v1))) +(let ((e31 (member e7 e19))) +(let ((e32 (f1 e12 e12))) +(let ((e33 (f1 e16 e25))) +(let ((e34 (f1 v1 e27))) +(let ((e35 (f1 e19 e19))) +(let ((e36 (f1 e24 e32))) +(let ((e37 (f1 e28 e35))) +(let ((e38 (f1 e27 e20))) +(let ((e39 (f1 e23 e23))) +(let ((e40 (f1 e39 e27))) +(let ((e41 (f1 e17 e32))) +(let ((e42 (f1 e34 e33))) +(let ((e43 (f1 e34 e17))) +(let ((e44 (f1 e34 e25))) +(let ((e45 (f1 e26 e26))) +(let ((e46 (f1 e17 e21))) +(let ((e47 (f1 e40 e26))) +(let ((e48 (f1 e16 v2))) +(let ((e49 (f1 e46 e33))) +(let ((e50 (f1 e15 e15))) +(let ((e51 (f1 e18 e18))) +(let ((e52 (f1 e15 e18))) +(let ((e53 (f1 e11 e49))) +(let ((e54 (f1 e14 e42))) +(let ((e55 (f1 e48 e18))) +(let ((e56 (f1 e49 e52))) +(let ((e57 (f1 v4 e12))) +(let ((e58 (f1 e22 e45))) +(let ((e59 (f1 e13 e13))) +(let ((e60 (f1 v3 e36))) +(let ((e61 (distinct e8 e7))) +(let ((e62 (> v0 e8))) +(let ((e63 (< e10 e10))) +(let ((e64 (distinct v0 e10))) +(let ((e65 (<= e7 e8))) +(let ((e66 (distinct e9 v0))) +(let ((e67 (<= e6 e8))) +(let ((e68 (p0 e8 e7 e6))) +(let ((e69 (ite e63 e35 e13))) +(let ((e70 (ite e66 e25 e32))) +(let ((e71 (ite e62 e33 e19))) +(let ((e72 (ite e64 e46 v1))) +(let ((e73 (ite e65 e59 e51))) +(let ((e74 (ite e30 e14 e26))) +(let ((e75 (ite e68 e36 e39))) +(let ((e76 (ite e66 e35 e34))) +(let ((e77 (ite e64 e44 e54))) +(let ((e78 (ite e61 e70 e46))) +(let ((e79 (ite e31 e60 e26))) +(let ((e80 (ite e64 e55 e19))) +(let ((e81 (ite e63 e58 e33))) +(let ((e82 (ite e29 e32 e75))) +(let ((e83 (ite e67 e27 e73))) +(let ((e84 (ite e63 e51 e60))) +(let ((e85 (ite e64 e16 e73))) +(let ((e86 (ite e68 e47 e46))) +(let ((e87 (ite e67 v2 e11))) +(let ((e88 (ite e63 e59 e75))) +(let ((e89 (ite e30 e12 e83))) +(let ((e90 (ite e62 e45 e87))) +(let ((e91 (ite e29 e36 e89))) +(let ((e92 (ite e68 e24 e16))) +(let ((e93 (ite e61 e49 e76))) +(let ((e94 (ite e61 e12 e54))) +(let ((e95 (ite e67 e33 e16))) +(let ((e96 (ite e66 e26 e15))) +(let ((e97 (ite e65 e52 e13))) +(let ((e98 (ite e68 e38 e17))) +(let ((e99 (ite e65 e48 e46))) +(let ((e100 (ite e31 v3 e95))) +(let ((e101 (ite e31 e95 e18))) +(let ((e102 (ite e66 e37 e78))) +(let ((e103 (ite e31 e33 e17))) +(let ((e104 (ite e62 e55 e91))) +(let ((e105 (ite e65 e20 e90))) +(let ((e106 (ite e63 e22 e79))) +(let ((e107 (ite e64 e94 e97))) +(let ((e108 (ite e61 e53 e80))) +(let ((e109 (ite e63 e23 e52))) +(let ((e110 (ite e31 e100 e101))) +(let ((e111 (ite e68 e28 e98))) +(let ((e112 (ite e62 e50 e74))) +(let ((e113 (ite e30 e49 e96))) +(let ((e114 (ite e67 e14 e40))) +(let ((e115 (ite e61 e92 e91))) +(let ((e116 (ite e65 e18 e89))) +(let ((e117 (ite e63 e34 e51))) +(let ((e118 (ite e64 e56 e47))) +(let ((e119 (ite e68 e102 e18))) +(let ((e120 (ite e61 e43 e53))) +(let ((e121 (ite e31 e41 e98))) +(let ((e122 (ite e67 e114 e103))) +(let ((e123 (ite e65 v4 e92))) +(let ((e124 (ite e68 e33 e88))) +(let ((e125 (ite e68 e37 e101))) +(let ((e126 (ite e31 e36 e26))) +(let ((e127 (ite e65 e21 e95))) +(let ((e128 (ite e62 e42 v4))) +(let ((e129 (ite e66 e100 e19))) +(let ((e130 (ite e66 e78 e12))) +(let ((e131 (ite e62 e34 e103))) +(let ((e132 (ite e64 e59 e14))) +(let ((e133 (ite e31 e53 e89))) +(let ((e134 (ite e66 e57 e60))) +(let ((e135 (ite e31 e7 e10))) +(let ((e136 (ite e67 e10 e9))) +(let ((e137 (ite e65 e136 v0))) +(let ((e138 (ite e68 e6 e7))) +(let ((e139 (ite e66 e9 e9))) +(let ((e140 (ite e62 e8 e135))) +(let ((e141 (ite e30 e137 e6))) +(let ((e142 (ite e30 e140 e138))) +(let ((e143 (ite e29 e140 e6))) +(let ((e144 (ite e67 e141 v0))) +(let ((e145 (ite e62 e6 e137))) +(let ((e146 (ite e29 e137 e139))) +(let ((e147 (ite e30 e140 e144))) +(let ((e148 (ite e66 e142 e141))) +(let ((e149 (ite e63 e8 e144))) +(let ((e150 (ite e31 e135 e140))) +(let ((e151 (ite e64 e147 e141))) +(let ((e152 (ite e61 e147 e148))) +(let ((e153 (or e30 e63))) +(let ((e154 (or e67 e62))) +(let ((e155 (ite e154 e29 e154))) +(let ((e156 (and e66 e155))) +(let ((e157 (=> e31 e64))) +(let ((e158 (or e65 e153))) +(let ((e159 (not e158))) +(let ((e160 (xor e157 e68))) +(let ((e161 (xor e159 e61))) +(let ((e162 (= e156 e160))) +(let ((e163 (or e161 e161))) +(let ((e164 (not e162))) +(let ((e165 (=> e164 e163))) +e165 +)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +(check-sat) diff --git a/test/regress/regress1/sets/insert_invariant_37_2.smt2 b/test/regress/regress1/sets/insert_invariant_37_2.smt2 new file mode 100644 index 000000000..2ef07f920 --- /dev/null +++ b/test/regress/regress1/sets/insert_invariant_37_2.smt2 @@ -0,0 +1,812 @@ +(set-option :print-success false) +(set-logic AUFLIAFS) +(set-info :status unsat) +(declare-sort Loc 0) +(define-sort SetLoc () (Set Loc)) +(define-sort SetInt () (Set Int)) +(declare-sort FldLoc 0) +(declare-sort FldInt 0) +(declare-fun null$0 () Loc) +(declare-fun read$0 (FldInt Loc) Int) +(declare-fun read$1 (FldLoc Loc) Loc) +(declare-fun Btwn$0 (FldLoc Loc Loc Loc) Bool) +(declare-fun Alloc$0 () SetLoc) +(declare-fun Axiom$0 () Bool) +(declare-fun FP$0 () SetLoc) +(declare-fun FP_Caller$0 () SetLoc) +(declare-fun FP_Caller_1$0 () SetLoc) +(declare-fun c1_2$0 () SetInt) +(declare-fun c2_2$0 () SetInt) +(declare-fun content$0 () SetInt) +(declare-fun curr_2$0 () Loc) +(declare-fun data$0 () FldInt) +(declare-fun lst$0 () Loc) +(declare-fun next$0 () FldLoc) +(declare-fun prev_2$0 () Loc) +(declare-fun sk_?X$0 () SetLoc) +(declare-fun sk_?X_1$0 () SetLoc) +(declare-fun sk_?X_2$0 () SetLoc) +(declare-fun sk_?X_3$0 () SetLoc) +(declare-fun sk_?X_4$0 () SetLoc) +(declare-fun sk_?X_5$0 () SetLoc) +(declare-fun sk_?e$0 () Int) +(declare-fun sk_?e_1$0 () Loc) +(declare-fun sk_?e_2$0 () Loc) +(declare-fun sk_?e_3$0 () Int) +(declare-fun sk_FP$0 () SetLoc) +(declare-fun sk_FP_1$0 () SetLoc) +(declare-fun sk_l1$0 () Loc) +(declare-fun sk_l1_1$0 () Loc) +(declare-fun sk_l2$0 () Loc) +(declare-fun sk_l2_1$0 () Loc) +(declare-fun sorted_set_c$0 (FldInt FldLoc Loc Loc) SetInt) +(declare-fun sorted_set_domain$0 (FldInt FldLoc Loc Loc) SetLoc) +(declare-fun sorted_set_struct$0 (SetLoc FldInt FldLoc Loc Loc SetInt) Bool) +(declare-fun val$0 () Int) +(declare-fun witness$0 (Int SetInt) Loc) + +(assert (! (forall ((?y Loc)) + (or (not (Btwn$0 next$0 null$0 ?y ?y)) (= null$0 ?y) + (Btwn$0 next$0 null$0 (read$1 next$0 null$0) ?y))) + :named btwn_reach)) + +(assert (! (forall ((?y Loc)) + (or (not (= (read$1 next$0 null$0) null$0)) + (not (Btwn$0 next$0 null$0 ?y ?y)) (= null$0 ?y))) + :named btwn_cycl)) + +(assert (! (Btwn$0 next$0 null$0 (read$1 next$0 null$0) (read$1 next$0 null$0)) + :named btwn_step)) + +(assert (! (forall ((l1 Loc) (l2 Loc)) + (or (not Axiom$0) + (or (= l1 l2) (< (read$0 data$0 l1) (read$0 data$0 l2)) + (not (Btwn$0 next$0 l1 l2 null$0)) (not (member l1 sk_?X$0)) + (not (member l2 sk_?X$0))))) + :named strict_sortedness)) + +(assert (! (forall ((l1 Loc)) + (or (= l1 null$0) + (member (read$0 data$0 l1) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (not (Btwn$0 next$0 lst$0 l1 null$0)))) + :named sorted_set_1)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= (read$0 data$0 curr_2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not + (member (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= (read$0 data$0 prev_2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not + (member (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2_1)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not + (member (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2_2)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l1_1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not + (member (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2_3)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not + (member (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2_4)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l2_1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not + (member (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2_5)) + +(assert (! (and + (or + (= + (witness$0 sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= sk_?e$0 + (read$0 data$0 + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2_6)) + +(assert (! (and + (or + (= + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + null$0) + (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0))) + (or + (and + (= sk_?e_3$0 + (read$0 data$0 + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 lst$0 null$0)))) + (member + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 null$0))) + (not (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0))))) + :named sorted_set_2_7)) + +(assert (! (forall ((l1 Loc)) + (or (= l1 null$0) + (member (read$0 data$0 l1) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (not (Btwn$0 next$0 curr_2$0 l1 null$0)))) + :named sorted_set_1_1)) + +(assert (! (forall ((l1 Loc)) + (or (= l1 curr_2$0) + (member (read$0 data$0 l1) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (not (Btwn$0 next$0 lst$0 l1 curr_2$0)))) + :named sorted_set_1_2)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= (read$0 data$0 curr_2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not + (member (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_8)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= (read$0 data$0 prev_2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not + (member (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_9)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not + (member (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_10)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l1_1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not + (member (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_11)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not + (member (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_12)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= (read$0 data$0 sk_l2_1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not + (member (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_13)) + +(assert (! (and + (or + (= + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= sk_?e$0 + (read$0 data$0 + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_14)) + +(assert (! (and + (or + (= + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + null$0) + (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))) + (or + (and + (= sk_?e_3$0 + (read$0 data$0 + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (member + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))) + (not + (member sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))) + :named sorted_set_2_15)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= (read$0 data$0 curr_2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not + (member (read$0 data$0 curr_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_16)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= (read$0 data$0 prev_2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not + (member (read$0 data$0 prev_2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_17)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= (read$0 data$0 sk_l1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not + (member (read$0 data$0 sk_l1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_18)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= (read$0 data$0 sk_l1_1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not + (member (read$0 data$0 sk_l1_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_19)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= (read$0 data$0 sk_l2$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not + (member (read$0 data$0 sk_l2$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_20)) + +(assert (! (and + (or + (= + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= (read$0 data$0 sk_l2_1$0) + (read$0 data$0 + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not + (member (read$0 data$0 sk_l2_1$0) + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_21)) + +(assert (! (and + (or + (= + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= sk_?e$0 + (read$0 data$0 + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 sk_?e$0 + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_22)) + +(assert (! (and + (or + (= + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + null$0) + (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))) + (or + (and + (= sk_?e_3$0 + (read$0 data$0 + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (member + (witness$0 sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))) + (not + (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))) + :named sorted_set_2_23)) + +(assert (! (= (read$1 next$0 null$0) null$0) :named read_null)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 lst$0 l1 null$0) + (member l1 (sorted_set_domain$0 data$0 next$0 lst$0 null$0)) + (not (= l1 null$0))) + (and (or (= l1 null$0) (not (Btwn$0 next$0 lst$0 l1 null$0))) + (not + (member l1 + (sorted_set_domain$0 data$0 next$0 lst$0 null$0)))))) + :named sorted_set_footprint)) + +(assert (! (or (member sk_?e_3$0 c2_2$0) + (and (member sk_?e_2$0 sk_FP_1$0) (not (member sk_?e_2$0 FP$0))) + (and (member sk_?e_3$0 (union c1_2$0 c2_2$0)) + (not (member sk_?e_3$0 content$0))) + (and (member sk_?e_3$0 c1_2$0) + (not + (member sk_?e_3$0 + (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (and (member sk_?e_3$0 content$0) + (not (member sk_?e_3$0 (union c1_2$0 c2_2$0)))) + (and (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (not (member sk_?e_3$0 c1_2$0))) + (and (not (= curr_2$0 null$0)) (not (= prev_2$0 null$0)) + (not (< (read$0 data$0 prev_2$0) (read$0 data$0 curr_2$0)))) + (not (= curr_2$0 lst$0)) (not (= prev_2$0 null$0)) + (not + (sorted_set_struct$0 sk_?X_3$0 data$0 next$0 curr_2$0 null$0 + c1_2$0))) + :named invariant_37_2)) + +(assert (! (= sk_FP_1$0 sk_?X_2$0) :named invariant_37_2_1)) + +(assert (! (= sk_?X_5$0 (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)) + :named invariant_37_2_2)) + +(assert (! (= sk_?X_3$0 (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)) + :named invariant_37_2_3)) + +(assert (! (= sk_?X_1$0 (union sk_?X_3$0 sk_?X_4$0)) :named invariant_37_2_4)) + +(assert (! (= FP_Caller$0 (union FP$0 FP_Caller$0)) + :named precondition_of_insert_27_11)) + +(assert (! (= sk_?X$0 FP$0) :named precondition_of_insert_27_11_1)) + +(assert (! (= Alloc$0 (union FP_Caller$0 Alloc$0)) + :named initial_footprint_of_insert_27_11)) + +(assert (! (= curr_2$0 lst$0) :named assign_31_2)) + +(assert (! (= c1_2$0 content$0) :named assign_34_2)) + +(assert (! (or (and (Btwn$0 next$0 lst$0 null$0 null$0) Axiom$0) + (not + (sorted_set_struct$0 sk_?X$0 data$0 next$0 lst$0 null$0 + content$0))) + :named unnamed)) + +(assert (! (or (sorted_set_struct$0 sk_?X_3$0 data$0 next$0 curr_2$0 null$0 c1_2$0) + (not (Btwn$0 next$0 curr_2$0 null$0 null$0)) + (! (and (Btwn$0 next$0 sk_l1$0 sk_l2$0 null$0) (member sk_l1$0 sk_?X_3$0) + (member sk_l2$0 sk_?X_3$0) (not (= sk_l1$0 sk_l2$0)) + (not (< (read$0 data$0 sk_l1$0) (read$0 data$0 sk_l2$0)))) + :named strict_sortedness_1)) + :named unnamed_1)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 lst$0 l1 curr_2$0) + (member l1 + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)) + (not (= l1 curr_2$0))) + (and + (or (= l1 curr_2$0) + (not (Btwn$0 next$0 lst$0 l1 curr_2$0))) + (not + (member l1 + (sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))))) + :named sorted_set_footprint_1)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 curr_2$0 l1 null$0) + (member l1 + (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)) + (not (= l1 null$0))) + (and + (or (= l1 null$0) + (not (Btwn$0 next$0 curr_2$0 l1 null$0))) + (not + (member l1 + (sorted_set_domain$0 data$0 next$0 curr_2$0 + null$0)))))) + :named sorted_set_footprint_2)) + +(assert (! (not (member null$0 Alloc$0)) :named initial_footprint_of_insert_27_11_1)) + +(assert (! (or (= prev_2$0 curr_2$0) + (member sk_?e_1$0 (intersection sk_?X_4$0 sk_?X_3$0)) + (and (member sk_?e_1$0 sk_FP$0) (not (member sk_?e_1$0 FP$0))) + (and (member sk_?e$0 (union c1_2$0 c2_2$0)) (not (member sk_?e$0 content$0))) + (and (member sk_?e$0 c1_2$0) + (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))) + (and (member sk_?e$0 c2_2$0) + (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))) + (and (member sk_?e$0 content$0) (not (member sk_?e$0 (union c1_2$0 c2_2$0)))) + (and (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)) + (not (member sk_?e$0 c1_2$0))) + (and (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)) + (not (member sk_?e$0 c2_2$0))) + (and (not (= curr_2$0 null$0)) (not (= prev_2$0 null$0)) + (not (< (read$0 data$0 prev_2$0) (read$0 data$0 curr_2$0)))) + (not (= (read$1 next$0 prev_2$0) curr_2$0)) + (not (> val$0 (read$0 data$0 prev_2$0))) + (not (Btwn$0 next$0 lst$0 prev_2$0 curr_2$0)) + (not + (sorted_set_struct$0 sk_?X_3$0 data$0 next$0 curr_2$0 null$0 + c1_2$0)) + (not + (sorted_set_struct$0 sk_?X_5$0 data$0 next$0 lst$0 curr_2$0 + c2_2$0))) + :named invariant_37_2_5)) + +(assert (! (= sk_FP$0 sk_?X_1$0) :named invariant_37_2_6)) + +(assert (! (= sk_?X_4$0 sk_?X_5$0) :named invariant_37_2_7)) + +(assert (! (= sk_?X_2$0 sk_?X_3$0) :named invariant_37_2_8)) + +(assert (! (sorted_set_struct$0 sk_?X$0 data$0 next$0 lst$0 null$0 content$0) + :named precondition_of_insert_27_11_2)) + +(assert (! (= sk_?X$0 (sorted_set_domain$0 data$0 next$0 lst$0 null$0)) + :named precondition_of_insert_27_11_3)) + +(assert (! (= content$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)) + :named precondition_of_insert_27_11_4)) + +(assert (! (= prev_2$0 null$0) :named assign_32_2)) + +(assert (! (= c2_2$0 (as emptyset SetInt)) :named assign_35_2)) + +(assert (! (= FP_Caller_1$0 (setminus FP_Caller$0 FP$0)) :named assign_29_0)) + +(assert (! (or (sorted_set_struct$0 sk_?X_5$0 data$0 next$0 lst$0 curr_2$0 c2_2$0) + (not (Btwn$0 next$0 lst$0 curr_2$0 curr_2$0)) + (! (and (Btwn$0 next$0 sk_l1_1$0 sk_l2_1$0 curr_2$0) + (member sk_l1_1$0 sk_?X_5$0) (member sk_l2_1$0 sk_?X_5$0) + (not (= sk_l1_1$0 sk_l2_1$0)) + (not (< (read$0 data$0 sk_l1_1$0) (read$0 data$0 sk_l2_1$0)))) + :named strict_sortedness_2)) + :named unnamed_2)) + +(assert (! (forall ((?x Loc)) (Btwn$0 next$0 ?x ?x ?x)) :named btwn_refl)) + +(assert (! (forall ((?x Loc) (?y Loc)) (or (not (Btwn$0 next$0 ?x ?y ?x)) (= ?x ?y))) + :named btwn_sndw)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?y)) (not (Btwn$0 next$0 ?x ?z ?z)) + (Btwn$0 next$0 ?x ?y ?z) (Btwn$0 next$0 ?x ?z ?y))) + :named btwn_ord1)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) + (and (Btwn$0 next$0 ?x ?y ?y) (Btwn$0 next$0 ?y ?z ?z)))) + :named btwn_ord2)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?y)) (not (Btwn$0 next$0 ?y ?z ?z)) + (Btwn$0 next$0 ?x ?z ?z))) + :named btwn_trn1)) + +(assert (! (forall ((?u Loc) (?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) (not (Btwn$0 next$0 ?y ?u ?z)) + (and (Btwn$0 next$0 ?x ?y ?u) (Btwn$0 next$0 ?x ?u ?z)))) + :named btwn_trn2)) + +(assert (! (forall ((?u Loc) (?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) (not (Btwn$0 next$0 ?x ?u ?y)) + (and (Btwn$0 next$0 ?x ?u ?z) (Btwn$0 next$0 ?u ?y ?z)))) + :named btwn_trn3)) + +(check-sat) +(exit) diff --git a/test/regress/regress1/sets/lemmabug-ListElts317minimized.smt2 b/test/regress/regress1/sets/lemmabug-ListElts317minimized.smt2 new file mode 100644 index 000000000..0fc8ca067 --- /dev/null +++ b/test/regress/regress1/sets/lemmabug-ListElts317minimized.smt2 @@ -0,0 +1,89 @@ +; EXPECT: sat + +; Observed behavior: +; --check-model failed for set-term (union (z3f69 z3v151) (singleton z3v143)) +; with different set of elements in the model for representative and the node +; itself. +; +; Issue: +; The trouble with data structure being mainted to ensure that things +; for which lemmas have been generated are not generated again. This +; data structure (d_pendingEverInserted) needs to be user context +; dependent. The bug was in the sequence of steps from requesting that +; a lemma be generated to when it actually was. Sequence was: +; addToPending (and also adds to pending ever inserted) -> +; isComplete (might remove things from pending if requirment met in other ways) -> +; getLemma (actually generated the lemma, if requirement not already met) +; +; Resolution: +; adding terms to d_pendingEverInserted was moved from addToPending() +; to getLemma(). + +(set-logic QF_ALL_SUPPORTED) +(set-info :status sat) +(define-sort Elt () Int) +(define-sort mySet () (Set Elt )) +(define-fun smt_set_emp () mySet (as emptyset mySet)) +(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s)) +(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x))) +(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2)) +(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2)) +;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s)) +(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2)) +;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2))) +(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2)) + +(declare-fun z3v58 () Int) +(declare-fun z3v59 () Int) +(assert (distinct z3v58 z3v59)) + +(declare-fun z3f60 (Int) Bool) +(declare-fun z3v61 () Int) +(declare-fun z3f62 (Int) Int) +(declare-fun z3v63 () Int) +(declare-fun z3v64 () Int) +(declare-fun z3v67 () Int) +(declare-fun z3f68 (Int) Int) +(declare-fun z3f69 (Int) mySet) +(declare-fun z3f70 (Int) mySet) +(declare-fun z3f71 (Int) Bool) +(declare-fun z3v90 () Int) +(declare-fun z3v91 () Int) +(declare-fun z3f92 (Int Int) Int) +(declare-fun z3v140 () Int) +(declare-fun z3v141 () Int) +(declare-fun z3v142 () Int) +(declare-fun z3v143 () Int) +(declare-fun z3v144 () Int) +(declare-fun z3v145 () Int) +(declare-fun z3v147 () Int) +(declare-fun z3v150 () Int) +(declare-fun z3v151 () Int) +(declare-fun z3v152 () Int) + +(assert (not (= (z3f69 z3v152) + (z3f69 z3v140)))) + +(assert (= (z3f69 z3v151) + (smt_set_cup (z3f69 z3v141) + (z3f69 z3v140)))) + +(assert (= (z3f69 z3v152) + (smt_set_cup (singleton z3v143) (z3f69 z3v151)))) + +(assert (= (z3f70 z3v152) + (smt_set_cup (singleton z3v143) (z3f70 z3v151)))) + +(assert (and + (= (z3f69 z3v142) + (smt_set_cup (singleton z3v143) (z3f69 z3v141))) + (= (z3f70 z3v142) + (smt_set_cup (singleton z3v143) (z3f70 z3v141))) + (= z3v142 (z3f92 z3v143 z3v141)) + (= z3v142 z3v144) + (= (z3f62 z3v61) z3v61) + (= (z3f62 z3v63) z3v63) + ) + ) + +(check-sat) diff --git a/test/regress/regress1/sets/remove_check_free_31_6.smt2 b/test/regress/regress1/sets/remove_check_free_31_6.smt2 new file mode 100644 index 000000000..2bf2d4c62 --- /dev/null +++ b/test/regress/regress1/sets/remove_check_free_31_6.smt2 @@ -0,0 +1,470 @@ +(set-option :print-success false) +(set-logic AUFLIAFS) +(set-info :status unsat) +(declare-sort Loc 0) +(define-sort SetLoc () (Set Loc)) +(define-sort SetInt () (Set Int)) +(declare-sort FldLoc 0) +(declare-sort FldInt 0) +(declare-fun null$0 () Loc) +(declare-fun read$0 (FldLoc Loc) Loc) +(declare-fun write$0 (FldLoc Loc Loc) FldLoc) +(declare-fun ep$0 (FldLoc SetLoc Loc) Loc) +(declare-fun Btwn$0 (FldLoc Loc Loc Loc) Bool) +(declare-fun Frame$0 (SetLoc SetLoc FldLoc FldLoc) Bool) +(declare-fun Alloc$0 () SetLoc) +(declare-fun FP$0 () SetLoc) +(declare-fun FP_1$0 () SetLoc) +(declare-fun FP_2$0 () SetLoc) +(declare-fun FP_Caller$0 () SetLoc) +(declare-fun FP_Caller_1$0 () SetLoc) +(declare-fun curr_2$0 () Loc) +(declare-fun curr_3$0 () Loc) +(declare-fun lseg_domain$0 (FldLoc Loc Loc) SetLoc) +(declare-fun lseg_struct$0 (SetLoc FldLoc Loc Loc) Bool) +(declare-fun lst$0 () Loc) +(declare-fun lst_1$0 () Loc) +(declare-fun next$0 () FldLoc) +(declare-fun next_1$0 () FldLoc) +(declare-fun nondet_2$0 () Bool) +(declare-fun sk_?X_27$0 () SetLoc) +(declare-fun sk_?X_28$0 () SetLoc) +(declare-fun sk_?X_29$0 () SetLoc) +(declare-fun sk_?X_30$0 () SetLoc) +(declare-fun sk_?X_31$0 () SetLoc) +(declare-fun sk_?X_32$0 () SetLoc) +(declare-fun sk_?X_33$0 () SetLoc) +(declare-fun tmp_2$0 () Loc) + +(assert (! (forall ((?y Loc)) + (or (not (Btwn$0 next$0 null$0 ?y ?y)) (= null$0 ?y) + (Btwn$0 next$0 null$0 (read$0 next$0 null$0) ?y))) + :named btwn_reach_8)) + +(assert (! (forall ((?y Loc)) + (or (not (Btwn$0 next$0 tmp_2$0 ?y ?y)) (= tmp_2$0 ?y) + (Btwn$0 next$0 tmp_2$0 (read$0 next$0 tmp_2$0) ?y))) + :named btwn_reach_9)) + +(assert (! (forall ((?y Loc)) + (or (not (Btwn$0 next$0 curr_3$0 ?y ?y)) (= curr_3$0 ?y) + (Btwn$0 next$0 curr_3$0 (read$0 next$0 curr_3$0) ?y))) + :named btwn_reach_10)) + +(assert (! (forall ((?y Loc)) + (or (not (= (read$0 next$0 null$0) null$0)) + (not (Btwn$0 next$0 null$0 ?y ?y)) (= null$0 ?y))) + :named btwn_cycl_8)) + +(assert (! (forall ((?y Loc)) + (or (not (= (read$0 next$0 tmp_2$0) tmp_2$0)) + (not (Btwn$0 next$0 tmp_2$0 ?y ?y)) (= tmp_2$0 ?y))) + :named btwn_cycl_9)) + +(assert (! (forall ((?y Loc)) + (or (not (= (read$0 next$0 curr_3$0) curr_3$0)) + (not (Btwn$0 next$0 curr_3$0 ?y ?y)) (= curr_3$0 ?y))) + :named btwn_cycl_10)) + +(assert (! (Btwn$0 next$0 null$0 (read$0 next$0 null$0) (read$0 next$0 null$0)) + :named btwn_step_8)) + +(assert (! (Btwn$0 next$0 tmp_2$0 (read$0 next$0 tmp_2$0) (read$0 next$0 tmp_2$0)) + :named btwn_step_9)) + +(assert (! (Btwn$0 next$0 curr_3$0 (read$0 next$0 curr_3$0) (read$0 next$0 curr_3$0)) + :named btwn_step_10)) + +(assert (! (forall ((?f FldLoc)) + (or (member (ep$0 ?f sk_?X_30$0 null$0) sk_?X_30$0) + (= null$0 (ep$0 ?f sk_?X_30$0 null$0)))) + :named entry-point3_10)) + +(assert (! (forall ((?f FldLoc)) + (or (member (ep$0 ?f sk_?X_30$0 lst_1$0) sk_?X_30$0) + (= lst_1$0 (ep$0 ?f sk_?X_30$0 lst_1$0)))) + :named entry-point3_11)) + +(assert (! (forall ((?f FldLoc)) + (or (member (ep$0 ?f sk_?X_30$0 curr_3$0) sk_?X_30$0) + (= curr_3$0 (ep$0 ?f sk_?X_30$0 curr_3$0)))) + :named entry-point3_12)) + +(assert (! (forall ((?f FldLoc)) + (or (member (ep$0 ?f sk_?X_30$0 tmp_2$0) sk_?X_30$0) + (= tmp_2$0 (ep$0 ?f sk_?X_30$0 tmp_2$0)))) + :named entry-point3_13)) + +(assert (! (forall ((?f FldLoc)) + (Btwn$0 ?f null$0 (ep$0 ?f sk_?X_30$0 null$0) + (ep$0 ?f sk_?X_30$0 null$0))) + :named entry-point1_10)) + +(assert (! (forall ((?f FldLoc)) + (Btwn$0 ?f lst_1$0 (ep$0 ?f sk_?X_30$0 lst_1$0) + (ep$0 ?f sk_?X_30$0 lst_1$0))) + :named entry-point1_11)) + +(assert (! (forall ((?f FldLoc)) + (Btwn$0 ?f curr_3$0 (ep$0 ?f sk_?X_30$0 curr_3$0) + (ep$0 ?f sk_?X_30$0 curr_3$0))) + :named entry-point1_12)) + +(assert (! (forall ((?f FldLoc)) + (Btwn$0 ?f tmp_2$0 (ep$0 ?f sk_?X_30$0 tmp_2$0) + (ep$0 ?f sk_?X_30$0 tmp_2$0))) + :named entry-point1_13)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (Btwn$0 ?f null$0 (ep$0 ?f sk_?X_30$0 null$0) ?y) + (not (Btwn$0 ?f null$0 ?y ?y)) (not (member ?y sk_?X_30$0)))) + :named entry-point4_10)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (Btwn$0 ?f lst_1$0 (ep$0 ?f sk_?X_30$0 lst_1$0) ?y) + (not (Btwn$0 ?f lst_1$0 ?y ?y)) (not (member ?y sk_?X_30$0)))) + :named entry-point4_11)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (Btwn$0 ?f curr_3$0 (ep$0 ?f sk_?X_30$0 curr_3$0) ?y) + (not (Btwn$0 ?f curr_3$0 ?y ?y)) (not (member ?y sk_?X_30$0)))) + :named entry-point4_12)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (Btwn$0 ?f tmp_2$0 (ep$0 ?f sk_?X_30$0 tmp_2$0) ?y) + (not (Btwn$0 ?f tmp_2$0 ?y ?y)) (not (member ?y sk_?X_30$0)))) + :named entry-point4_13)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (not (Btwn$0 ?f null$0 ?y ?y)) (not (member ?y sk_?X_30$0)) + (member (ep$0 ?f sk_?X_30$0 null$0) sk_?X_30$0))) + :named entry-point2_10)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (not (Btwn$0 ?f lst_1$0 ?y ?y)) (not (member ?y sk_?X_30$0)) + (member (ep$0 ?f sk_?X_30$0 lst_1$0) sk_?X_30$0))) + :named entry-point2_11)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (not (Btwn$0 ?f curr_3$0 ?y ?y)) (not (member ?y sk_?X_30$0)) + (member (ep$0 ?f sk_?X_30$0 curr_3$0) sk_?X_30$0))) + :named entry-point2_12)) + +(assert (! (forall ((?f FldLoc) (?y Loc)) + (or (not (Btwn$0 ?f tmp_2$0 ?y ?y)) (not (member ?y sk_?X_30$0)) + (member (ep$0 ?f sk_?X_30$0 tmp_2$0) sk_?X_30$0))) + :named entry-point2_13)) + +(assert (! (= (read$0 (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0)) curr_3$0) + (read$0 next$0 tmp_2$0)) + :named read_write2)) + +(assert (! (or (= null$0 curr_3$0) + (= (read$0 next$0 null$0) + (read$0 (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0)) null$0))) + :named read_write1)) + +(assert (! (or (= tmp_2$0 curr_3$0) + (= (read$0 next$0 tmp_2$0) + (read$0 (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0)) tmp_2$0))) + :named read_write1_1)) + +(assert (! (or (= curr_3$0 curr_3$0) + (= (read$0 next$0 curr_3$0) + (read$0 (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0)) curr_3$0))) + :named read_write1_2)) + +(assert (! (= (read$0 next$0 null$0) null$0) :named read_null_5)) + +(assert (! (= (read$0 next_1$0 null$0) null$0) :named read_null_6)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 lst$0 l1 curr_2$0) + (member l1 (lseg_domain$0 next$0 lst$0 curr_2$0)) + (not (= l1 curr_2$0))) + (and + (or (= l1 curr_2$0) + (not (Btwn$0 next$0 lst$0 l1 curr_2$0))) + (not (member l1 (lseg_domain$0 next$0 lst$0 curr_2$0)))))) + :named lseg_footprint_20)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 curr_3$0 l1 null$0) + (member l1 (lseg_domain$0 next$0 curr_3$0 null$0)) + (not (= l1 null$0))) + (and + (or (= l1 null$0) + (not (Btwn$0 next$0 curr_3$0 l1 null$0))) + (not (member l1 (lseg_domain$0 next$0 curr_3$0 null$0)))))) + :named lseg_footprint_21)) + +(assert (! (not (member tmp_2$0 FP_2$0)) :named check_free_31_6)) + +(assert (! (not (member null$0 Alloc$0)) :named framecondition_of_remove_loop_18_4_15)) + +(assert (! (not (= lst$0 null$0)) :named if_else_13_6_4)) + +(assert (! (= FP_Caller$0 (union FP$0 FP_Caller$0)) + :named precondition_of_remove_10_11_20)) + +(assert (! (= sk_?X_33$0 FP$0) :named precondition_of_remove_10_11_21)) + +(assert (! (lseg_struct$0 sk_?X_32$0 next$0 lst$0 curr_2$0) :named invariant_18_4_62)) + +(assert (! (= FP$0 (union FP_1$0 FP$0)) :named invariant_18_4_63)) + +(assert (! (= sk_?X_31$0 (lseg_domain$0 next$0 curr_2$0 null$0)) + :named invariant_18_4_64)) + +(assert (! (= sk_?X_30$0 (union sk_?X_31$0 sk_?X_32$0)) :named invariant_18_4_65)) + +(assert (! (= (as emptyset SetLoc) (as emptyset SetLoc)) :named invariant_18_4_66)) + +(assert (! (lseg_struct$0 sk_?X_28$0 next$0 curr_3$0 null$0) + :named invariant_18_4_67)) + +(assert (! (= sk_?X_29$0 (union sk_?X_28$0 sk_?X_27$0)) :named invariant_18_4_68)) + +(assert (! (= sk_?X_28$0 (lseg_domain$0 next$0 curr_3$0 null$0)) + :named invariant_18_4_69)) + +(assert (! (= (as emptyset SetLoc) (intersection sk_?X_27$0 sk_?X_28$0)) + :named invariant_18_4_70)) + +(assert (! (= Alloc$0 (union FP_Caller$0 Alloc$0)) + :named initial_footprint_of_remove_10_11_10)) + +(assert (! (Frame$0 FP_1$0 Alloc$0 next$0 next$0) + :named framecondition_of_remove_loop_18_4_16)) + +(assert (! (= next_1$0 (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0))) + :named assign_30_6)) + +(assert (! (= curr_2$0 lst$0) :named assign_17_4_4)) + +(assert (! (= FP_2$0 + (union (setminus FP$0 FP_1$0) + (union (intersection Alloc$0 FP_1$0) (setminus Alloc$0 Alloc$0)))) + :named framecondition_of_remove_loop_18_4_17)) + +(assert (! (or (Btwn$0 next$0 lst$0 curr_2$0 curr_2$0) + (not (lseg_struct$0 sk_?X_32$0 next$0 lst$0 curr_2$0))) + :named unnamed_23)) + +(assert (! (or (Btwn$0 next$0 curr_3$0 null$0 null$0) + (not (lseg_struct$0 sk_?X_28$0 next$0 curr_3$0 null$0))) + :named unnamed_24)) + +(assert (! (or (= (read$0 next$0 curr_3$0) null$0) (not nondet_2$0)) + :named unnamed_25)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 lst_1$0 l1 curr_3$0) + (member l1 (lseg_domain$0 next$0 lst_1$0 curr_3$0)) + (not (= l1 curr_3$0))) + (and + (or (= l1 curr_3$0) + (not (Btwn$0 next$0 lst_1$0 l1 curr_3$0))) + (not (member l1 (lseg_domain$0 next$0 lst_1$0 curr_3$0)))))) + :named lseg_footprint_22)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 lst$0 l1 null$0) + (member l1 (lseg_domain$0 next$0 lst$0 null$0)) + (not (= l1 null$0))) + (and (or (= l1 null$0) (not (Btwn$0 next$0 lst$0 l1 null$0))) + (not (member l1 (lseg_domain$0 next$0 lst$0 null$0)))))) + :named lseg_footprint_23)) + +(assert (! (forall ((l1 Loc)) + (or + (and (Btwn$0 next$0 curr_2$0 l1 null$0) + (member l1 (lseg_domain$0 next$0 curr_2$0 null$0)) + (not (= l1 null$0))) + (and + (or (= l1 null$0) + (not (Btwn$0 next$0 curr_2$0 l1 null$0))) + (not (member l1 (lseg_domain$0 next$0 curr_2$0 null$0)))))) + :named lseg_footprint_24)) + +(assert (! (not (member null$0 Alloc$0)) :named initial_footprint_of_remove_10_11_11)) + +(assert (! (not (= tmp_2$0 null$0)) :named if_else_28_8_2)) + +(assert (! (lseg_struct$0 sk_?X_33$0 next$0 lst$0 null$0) + :named precondition_of_remove_10_11_22)) + +(assert (! (= sk_?X_33$0 (lseg_domain$0 next$0 lst$0 null$0)) + :named precondition_of_remove_10_11_23)) + +(assert (! (not (= curr_2$0 null$0)) :named invariant_18_4_71)) + +(assert (! (lseg_struct$0 sk_?X_31$0 next$0 curr_2$0 null$0) + :named invariant_18_4_72)) + +(assert (! (= sk_?X_32$0 (lseg_domain$0 next$0 lst$0 curr_2$0)) + :named invariant_18_4_73)) + +(assert (! (= sk_?X_30$0 FP_1$0) :named invariant_18_4_74)) + +(assert (! (= (as emptyset SetLoc) (intersection sk_?X_32$0 sk_?X_31$0)) + :named invariant_18_4_75)) + +(assert (! (not (= curr_3$0 null$0)) :named invariant_18_4_76)) + +(assert (! (lseg_struct$0 sk_?X_27$0 next$0 lst_1$0 curr_3$0) + :named invariant_18_4_77)) + +(assert (! (= sk_?X_29$0 + (union (intersection Alloc$0 FP_1$0) (setminus Alloc$0 Alloc$0))) + :named invariant_18_4_78)) + +(assert (! (= sk_?X_27$0 (lseg_domain$0 next$0 lst_1$0 curr_3$0)) + :named invariant_18_4_79)) + +(assert (! (= (as emptyset SetLoc) (as emptyset SetLoc)) :named invariant_18_4_80)) + +(assert (! (= Alloc$0 (union FP_2$0 Alloc$0)) + :named framecondition_of_remove_loop_18_4_18)) + +(assert (! (= tmp_2$0 (read$0 next$0 curr_3$0)) :named assign_27_4_2)) + +(assert (! (= lst_1$0 lst$0) :named framecondition_of_remove_loop_18_4_19)) + +(assert (! (= FP_Caller_1$0 (setminus FP_Caller$0 FP$0)) :named assign_13_2_5)) + +(assert (! (or (Btwn$0 next$0 lst_1$0 curr_3$0 curr_3$0) + (not (lseg_struct$0 sk_?X_27$0 next$0 lst_1$0 curr_3$0))) + :named unnamed_26)) + +(assert (! (or (Btwn$0 next$0 lst$0 null$0 null$0) + (not (lseg_struct$0 sk_?X_33$0 next$0 lst$0 null$0))) + :named unnamed_27)) + +(assert (! (or (Btwn$0 next$0 curr_2$0 null$0 null$0) + (not (lseg_struct$0 sk_?X_31$0 next$0 curr_2$0 null$0))) + :named unnamed_28)) + +(assert (! (forall ((?u Loc) (?v Loc) (?z Loc)) + (and + (or + (Btwn$0 (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0)) + ?z ?u ?v) + (not + (or + (and (Btwn$0 next$0 ?z ?u ?v) + (or (Btwn$0 next$0 ?z ?v curr_3$0) + (and (Btwn$0 next$0 ?z ?v ?v) + (not + (Btwn$0 next$0 ?z curr_3$0 + curr_3$0))))) + (and (not (= curr_3$0 ?v)) + (or (Btwn$0 next$0 ?z curr_3$0 ?v) + (and + (Btwn$0 next$0 ?z curr_3$0 + curr_3$0) + (not (Btwn$0 next$0 ?z ?v ?v)))) + (Btwn$0 next$0 ?z ?u curr_3$0) + (or + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) + ?v curr_3$0) + (and + (Btwn$0 next$0 + (read$0 next$0 tmp_2$0) ?v ?v) + (not + (Btwn$0 next$0 + (read$0 next$0 tmp_2$0) + curr_3$0 curr_3$0))))) + (and (not (= curr_3$0 ?v)) + (or (Btwn$0 next$0 ?z curr_3$0 ?v) + (and + (Btwn$0 next$0 ?z curr_3$0 + curr_3$0) + (not (Btwn$0 next$0 ?z ?v ?v)))) + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) ?u + ?v) + (or + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) + ?v curr_3$0) + (and + (Btwn$0 next$0 + (read$0 next$0 tmp_2$0) ?v ?v) + (not + (Btwn$0 next$0 + (read$0 next$0 tmp_2$0) + curr_3$0 curr_3$0)))))))) + (or + (and (Btwn$0 next$0 ?z ?u ?v) + (or (Btwn$0 next$0 ?z ?v curr_3$0) + (and (Btwn$0 next$0 ?z ?v ?v) + (not (Btwn$0 next$0 ?z curr_3$0 curr_3$0))))) + (and (not (= curr_3$0 ?v)) + (or (Btwn$0 next$0 ?z curr_3$0 ?v) + (and (Btwn$0 next$0 ?z curr_3$0 curr_3$0) + (not (Btwn$0 next$0 ?z ?v ?v)))) + (Btwn$0 next$0 ?z ?u curr_3$0) + (or + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) ?v + curr_3$0) + (and + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) ?v + ?v) + (not + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) + curr_3$0 curr_3$0))))) + (and (not (= curr_3$0 ?v)) + (or (Btwn$0 next$0 ?z curr_3$0 ?v) + (and (Btwn$0 next$0 ?z curr_3$0 curr_3$0) + (not (Btwn$0 next$0 ?z ?v ?v)))) + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) ?u ?v) + (or + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) ?v + curr_3$0) + (and + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) ?v + ?v) + (not + (Btwn$0 next$0 (read$0 next$0 tmp_2$0) + curr_3$0 curr_3$0))))) + (not + (Btwn$0 + (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0)) + ?z ?u ?v))))) + :named btwn_write)) + +(assert (! (forall ((?x Loc)) (Btwn$0 next$0 ?x ?x ?x)) :named btwn_refl_5)) + +(assert (! (forall ((?x Loc) (?y Loc)) (or (not (Btwn$0 next$0 ?x ?y ?x)) (= ?x ?y))) + :named btwn_sndw_5)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?y)) (not (Btwn$0 next$0 ?x ?z ?z)) + (Btwn$0 next$0 ?x ?y ?z) (Btwn$0 next$0 ?x ?z ?y))) + :named btwn_ord1_5)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) + (and (Btwn$0 next$0 ?x ?y ?y) (Btwn$0 next$0 ?y ?z ?z)))) + :named btwn_ord2_5)) + +(assert (! (forall ((?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?y)) (not (Btwn$0 next$0 ?y ?z ?z)) + (Btwn$0 next$0 ?x ?z ?z))) + :named btwn_trn1_5)) + +(assert (! (forall ((?u Loc) (?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) (not (Btwn$0 next$0 ?y ?u ?z)) + (and (Btwn$0 next$0 ?x ?y ?u) (Btwn$0 next$0 ?x ?u ?z)))) + :named btwn_trn2_5)) + +(assert (! (forall ((?u Loc) (?x Loc) (?y Loc) (?z Loc)) + (or (not (Btwn$0 next$0 ?x ?y ?z)) (not (Btwn$0 next$0 ?x ?u ?y)) + (and (Btwn$0 next$0 ?x ?u ?z) (Btwn$0 next$0 ?u ?y ?z)))) + :named btwn_trn3_5)) + +(check-sat) +(exit) diff --git a/test/regress/regress1/sets/setofsets-disequal.smt2 b/test/regress/regress1/sets/setofsets-disequal.smt2 new file mode 100644 index 000000000..1702aab27 --- /dev/null +++ b/test/regress/regress1/sets/setofsets-disequal.smt2 @@ -0,0 +1,64 @@ +; On a production build (as of 2014-05-16), takes several minutes +; to finish (2967466 decisions). + +(set-logic QF_BVFS) +(set-info :status unsat) + +(define-sort myset () (Set (Set (_ BitVec 1)))) +(declare-fun S () myset) + +; 0 elements +(assert (not (= S (as emptyset myset)))) + +; 1 element is S +(assert (not (= S (singleton (as emptyset (Set (_ BitVec 1))))))) +(assert (not (= S (singleton (singleton (_ bv0 1)) )))) +(assert (not (= S (singleton (singleton (_ bv1 1)) )))) +(assert (not (= S (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1))))))) + +; 2 elements in S +(assert (not (= S (union (singleton (as emptyset (Set (_ BitVec 1)))) + (singleton (singleton (_ bv0 1)))) ))) +(assert (not (= S (union (singleton (as emptyset (Set (_ BitVec 1)))) + (singleton (singleton (_ bv1 1))))))) +(assert (not (= S (union (singleton (as emptyset (Set (_ BitVec 1)))) + (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1)))))))) +(assert (not (= S (union (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1)))) + (singleton (singleton (_ bv0 1)))) ))) +(assert (not (= S (union (singleton (singleton (_ bv0 1))) + (singleton (singleton (_ bv1 1)))) ))) +(assert (not (= S (union (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1)))) + (singleton (singleton (_ bv1 1))))))) + +; 3 elements in S +(assert (not (= S (union (singleton (singleton (_ bv1 1))) + (union (singleton (as emptyset (Set (_ BitVec 1)))) + (singleton (singleton (_ bv0 1))))) ))) +(assert (not (= S (union (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1)))) + (union (singleton (as emptyset (Set (_ BitVec 1)))) + (singleton (singleton (_ bv1 1))))) ))) +(assert (not (= S (union (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1)))) + (union (singleton (singleton (_ bv0 1))) + (singleton (singleton (_ bv1 1))))) ))) +(assert (not (= S (union (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1)))) + (union (singleton (as emptyset (Set (_ BitVec 1)))) + (singleton (singleton (_ bv0 1))))) ))) + +; 4 elements in S +(assert (not (= S (union (singleton (union (singleton (_ bv0 1)) + (singleton (_ bv1 1)))) + (union (singleton (singleton (_ bv1 1))) + (union (singleton (as emptyset (Set (_ BitVec 1)))) + (singleton (singleton (_ bv0 1)))))) ))) + +(check-sat) + +; if you delete any of the above assertions, you should get sat +; (get-model) diff --git a/test/regress/regress1/sets/sets-tuple-poly.cvc b/test/regress/regress1/sets/sets-tuple-poly.cvc new file mode 100644 index 000000000..4cac9a24e --- /dev/null +++ b/test/regress/regress1/sets/sets-tuple-poly.cvc @@ -0,0 +1,17 @@ +% EXPECT: sat +OPTION "sets-ext"; +OPTION "logic" "ALL_SUPPORTED"; + +a : SET OF [REAL, INT]; +b : SET OF [INT, REAL]; + +x : [ REAL, REAL ]; + +ASSERT NOT x = (0.0,0.0); + +ASSERT (x.0, FLOOR(x.1)) IS_IN a; +ASSERT (FLOOR(x.0), x.1) IS_IN b; + +ASSERT NOT x.0 = x.1; + +CHECKSAT; diff --git a/test/regress/regress1/sets/sharingbug.smt2 b/test/regress/regress1/sets/sharingbug.smt2 new file mode 100644 index 000000000..b87579816 --- /dev/null +++ b/test/regress/regress1/sets/sharingbug.smt2 @@ -0,0 +1,157 @@ +(set-info :source |fuzzsmt|) +(set-info :smt-lib-version 2.0) +(set-info :category "random") +(set-info :status sat) +(set-logic QF_UFLIAFS) +(define-sort Element () Int) +(declare-fun f0 ( Int Int Int) Int) +(declare-fun f1 ( (Set Element)) (Set Element)) +(declare-fun p0 ( Int Int Int) Bool) +(declare-fun p1 ( (Set Element)) Bool) +(declare-fun v0 () Int) +(declare-fun v1 () (Set Element)) +(declare-fun v2 () (Set Element)) +(declare-fun v3 () (Set Element)) +(assert (let ((e4 1)) +(let ((e5 (- v0))) +(let ((e6 (* v0 (- e4)))) +(let ((e7 (ite (p0 v0 e5 v0) 1 0))) +(let ((e8 (- e6 e7))) +(let ((e9 (+ e5 v0))) +(let ((e10 (ite (p0 e7 e7 e5) 1 0))) +(let ((e11 (+ e8 e10))) +(let ((e12 (* (- e4) e7))) +(let ((e13 (- e10))) +(let ((e14 (f0 e5 e7 e6))) +(let ((e15 (member v0 v1))) +(let ((e16 (member e12 v2))) +(let ((e17 (member e14 v1))) +(let ((e18 (f1 v3))) +(let ((e19 (f1 v2))) +(let ((e20 (f1 v1))) +(let ((e21 (>= v0 e9))) +(let ((e22 (> e6 e6))) +(let ((e23 (> e5 e12))) +(let ((e24 (distinct e8 e11))) +(let ((e25 (= e10 e10))) +(let ((e26 (> e13 e13))) +(let ((e27 (distinct e14 e10))) +(let ((e28 (> e11 e5))) +(let ((e29 (>= e14 e6))) +(let ((e30 (< e14 e14))) +(let ((e31 (< e7 e12))) +(let ((e32 (<= e11 e12))) +(let ((e33 (< e14 e11))) +(let ((e34 (<= e7 e9))) +(let ((e35 (distinct e12 e5))) +(let ((e36 (= e14 e6))) +(let ((e37 (< v0 e8))) +(let ((e38 (< e13 e14))) +(let ((e39 (>= e6 e13))) +(let ((e40 (< e12 e13))) +(let ((e41 (< v0 e14))) +(let ((e42 (< v0 e11))) +(let ((e43 (p0 e13 e7 e8))) +(let ((e44 (ite e17 e19 e19))) +(let ((e45 (ite e34 v1 v1))) +(let ((e46 (ite e28 v1 e44))) +(let ((e47 (ite e24 e44 e20))) +(let ((e48 (ite e39 e18 v3))) +(let ((e49 (ite e35 v2 v3))) +(let ((e50 (ite e38 e18 e20))) +(let ((e51 (ite e22 v2 e44))) +(let ((e52 (ite e17 e20 e18))) +(let ((e53 (ite e35 e52 e19))) +(let ((e54 (ite e38 e49 e20))) +(let ((e55 (ite e15 e20 e45))) +(let ((e56 (ite e37 v1 v3))) +(let ((e57 (ite e41 e50 v1))) +(let ((e58 (ite e28 v1 e54))) +(let ((e59 (ite e27 e19 e53))) +(let ((e60 (ite e16 e46 e44))) +(let ((e61 (ite e29 e57 e52))) +(let ((e62 (ite e21 e50 e53))) +(let ((e63 (ite e32 e45 e19))) +(let ((e64 (ite e42 v3 e57))) +(let ((e65 (ite e33 e50 v3))) +(let ((e66 (ite e43 e49 e20))) +(let ((e67 (ite e22 v1 e63))) +(let ((e68 (ite e40 e45 e19))) +(let ((e69 (ite e30 e62 e58))) +(let ((e70 (ite e24 e52 e58))) +(let ((e71 (ite e31 e64 e67))) +(let ((e72 (ite e30 e18 e20))) +(let ((e73 (ite e25 e58 e44))) +(let ((e74 (ite e36 e63 v3))) +(let ((e75 (ite e43 e62 e73))) +(let ((e76 (ite e26 e61 e55))) +(let ((e77 (ite e23 e61 e71))) +(let ((e78 (ite e40 e13 v0))) +(let ((e79 (ite e23 e8 e13))) +(let ((e80 (ite e24 e78 e6))) +(let ((e81 (ite e39 e9 e80))) +(let ((e82 (ite e31 e7 v0))) +(let ((e83 (ite e43 e14 e6))) +(let ((e84 (ite e38 e80 e81))) +(let ((e85 (ite e32 e14 e10))) +(let ((e86 (ite e29 e84 e78))) +(let ((e87 (ite e27 e12 e8))) +(let ((e88 (ite e31 e11 e6))) +(let ((e89 (ite e33 e88 e85))) +(let ((e90 (ite e36 e12 v0))) +(let ((e91 (ite e23 e5 e7))) +(let ((e92 (ite e34 e89 e80))) +(let ((e93 (ite e15 e79 v0))) +(let ((e94 (ite e21 e6 e7))) +(let ((e95 (ite e26 v0 e91))) +(let ((e96 (ite e28 e94 e87))) +(let ((e97 (ite e32 e90 e78))) +(let ((e98 (ite e42 e78 e83))) +(let ((e99 (ite e40 e13 e82))) +(let ((e100 (ite e25 e88 e90))) +(let ((e101 (ite e26 e11 e81))) +(let ((e102 (ite e17 e101 e81))) +(let ((e103 (ite e30 v0 e80))) +(let ((e104 (ite e28 e80 e79))) +(let ((e105 (ite e27 e95 e101))) +(let ((e106 (ite e22 e92 e94))) +(let ((e107 (ite e16 e82 e94))) +(let ((e108 (ite e41 e10 e78))) +(let ((e109 (ite e37 e107 e84))) +(let ((e110 (ite e35 e89 e92))) +(let ((e111 (and e30 e37))) +(let ((e112 (=> e21 e41))) +(let ((e113 (ite e25 e33 e26))) +(let ((e114 (and e34 e38))) +(let ((e115 (=> e22 e43))) +(let ((e116 (and e24 e35))) +(let ((e117 (not e112))) +(let ((e118 (=> e27 e116))) +(let ((e119 (= e36 e15))) +(let ((e120 (= e42 e42))) +(let ((e121 (xor e29 e115))) +(let ((e122 (xor e39 e16))) +(let ((e123 (or e118 e32))) +(let ((e124 (not e28))) +(let ((e125 (=> e23 e40))) +(let ((e126 (ite e17 e123 e111))) +(let ((e127 (not e117))) +(let ((e128 (not e31))) +(let ((e129 (xor e121 e126))) +(let ((e130 (or e125 e119))) +(let ((e131 (=> e127 e114))) +(let ((e132 (or e113 e128))) +(let ((e133 (= e122 e124))) +(let ((e134 (not e130))) +(let ((e135 (or e133 e132))) +(let ((e136 (= e129 e135))) +(let ((e137 (=> e120 e120))) +(let ((e138 (or e134 e137))) +(let ((e139 (or e138 e138))) +(let ((e140 (and e139 e131))) +(let ((e141 (or e136 e136))) +(let ((e142 (= e140 e141))) +e142 +)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +(check-sat) diff --git a/test/regress/regress1/sets/univ-set-uf-elim.smt2 b/test/regress/regress1/sets/univ-set-uf-elim.smt2 new file mode 100644 index 000000000..a22f2a44f --- /dev/null +++ b/test/regress/regress1/sets/univ-set-uf-elim.smt2 @@ -0,0 +1,16 @@ +; EXPECT: (error "Extended set operators are not supported in default mode, try --sets-ext.") +; EXIT: 1 +(set-logic ALL) +(declare-fun a () Int) +(declare-fun f ((Set Bool)) Int) +(declare-fun s () (Set Bool)) + +(assert (member true s)) +(assert (member false s)) +(assert (= a (f (as univset (Set Bool))))) + +(assert (= (f (as emptyset (Set Bool))) 1)) +(assert (= (f (singleton true)) 2)) +(assert (= (f (singleton false)) 3)) +(assert (= (f (union (singleton true) (singleton false))) 4)) +(check-sat) diff --git a/test/regress/regress1/simple-rdl-definefun.smt2 b/test/regress/regress1/simple-rdl-definefun.smt2 new file mode 100644 index 000000000..6b38c6a70 --- /dev/null +++ b/test/regress/regress1/simple-rdl-definefun.smt2 @@ -0,0 +1,15 @@ +(set-logic QF_RDL) +(set-info :status unsat) +(set-info :notes | Simple test, based on simple-rdl.smt2, of define-sort and define-fun |) +(declare-fun x () Real) +(declare-fun y () Real) +(declare-sort U 0) +(define-sort A (x y) y) +(define-sort F (x) (A x x)) +(declare-fun x2 () (F Real)) +(define-fun minus ((x Real) (z Real)) (A (A U Bool) (A (F U) Real)) (- x z)) +(define-fun less ((x Real) (z Real)) Bool (< x z)) +(define-fun foo ((x (F Real)) (z (A U Real))) (F (F Bool)) (less x z)) +(assert (not (=> (foo (minus x y) 0) (less x y)))) +(check-sat) +(exit) diff --git a/test/regress/regress1/simplification_bug4.smt2 b/test/regress/regress1/simplification_bug4.smt2 new file mode 100644 index 000000000..0d62d6921 --- /dev/null +++ b/test/regress/regress1/simplification_bug4.smt2 @@ -0,0 +1,295 @@ +(set-logic QF_LIA) +;; Simplified benchmark, derived from NuSMV output durationThm_1.bmc_k100.smt2 +;; +;; Original version generated by Alberto Griggio <griggio@fbk.eu> +;; on Fri Feb 4 15:56:12 2011 +(declare-fun sb_0__AT0 () Bool) +(declare-fun si_0__AT0 () Int) +(declare-fun si_1__AT0 () Int) +(declare-fun sb_1__AT0 () Bool) +(declare-fun si_2__AT0 () Int) +(declare-fun si_3__AT0 () Int) +(declare-fun sb_2__AT0 () Bool) +(declare-fun si_4__AT0 () Int) +(declare-fun si_5__AT0 () Int) +(declare-fun sb_3__AT0 () Bool) +(declare-fun sb_4__AT0 () Bool) +(declare-fun sb_5__AT0 () Bool) +(declare-fun si_6__AT0 () Int) +(declare-fun si_7__AT0 () Int) +(declare-fun si_8__AT0 () Int) +(declare-fun si_9__AT0 () Int) +(declare-fun si_10__AT0 () Int) +(declare-fun si_11__AT0 () Int) +(declare-fun sb_6__AT0 () Bool) +(declare-fun sb_7__AT0 () Bool) +(declare-fun si_12__AT0 () Int) +(declare-fun si_13__AT0 () Int) +(declare-fun si_14__AT0 () Int) +(assert (let ((.def_61 (= si_2__AT0 si_4__AT0))) +(let ((.def_60 (= si_3__AT0 si_5__AT0))) +(let ((.def_62 (and .def_60 .def_61))) +(let ((.def_63 (and sb_2__AT0 .def_62))) +(let ((.def_59 (= si_8__AT0 0))) +(let ((.def_64 (and .def_59 .def_63))) +(let ((.def_58 (= si_11__AT0 0))) +(let ((.def_65 (and .def_58 .def_64))) +(let ((.def_53 (<= 1 si_0__AT0))) +(let ((.def_52 (<= 1 si_1__AT0))) +(let ((.def_54 (and .def_52 .def_53))) +(let ((.def_48 (<= si_0__AT0 si_6__AT0))) +(let ((.def_49 (not .def_48))) +(let ((.def_50 (or sb_4__AT0 .def_49))) +(let ((.def_55 (and .def_50 .def_54))) +(let ((.def_45 (<= si_1__AT0 si_9__AT0))) +(let ((.def_46 (not .def_45))) +(let ((.def_47 (or sb_5__AT0 .def_46))) +(let ((.def_56 (and .def_47 .def_55))) +(let ((.def_57 (= sb_7__AT0 .def_56))) +(let ((.def_66 (and .def_57 .def_65))) +(let ((.def_44 (= si_14__AT0 0))) +(let ((.def_67 (and .def_44 .def_66))) +(let ((.def_33 (not sb_1__AT0))) +(let ((.def_34 (or sb_2__AT0 .def_33))) +(let ((.def_35 (= sb_0__AT0 .def_34))) +(let ((.def_32 (= si_0__AT0 si_2__AT0))) +(let ((.def_36 (and .def_32 .def_35))) +(let ((.def_31 (= si_1__AT0 si_3__AT0))) +(let ((.def_37 (and .def_31 .def_36))) +(let ((.def_30 (= sb_1__AT0 sb_6__AT0))) +(let ((.def_38 (and .def_30 .def_37))) +(let ((.def_29 (= si_6__AT0 si_8__AT0))) +(let ((.def_39 (and .def_29 .def_38))) +(let ((.def_28 (= si_9__AT0 si_11__AT0))) +(let ((.def_40 (and .def_28 .def_39))) +(let ((.def_27 (= sb_6__AT0 sb_7__AT0))) +(let ((.def_41 (and .def_27 .def_40))) +(let ((.def_26 (= si_12__AT0 si_14__AT0))) +(let ((.def_42 (and .def_26 .def_41))) +(let ((.def_68 (and .def_42 .def_67))) +.def_68 +)))))))))))))))))))))))))))))))))))))))))) + +; (push 1) +; (assert (let ((.def_69 (not sb_0__AT0))) +; .def_69 +; )) +; (check-sat) +; (pop 1) + +(declare-fun sb_0__AT1 () Bool) +(declare-fun si_0__AT1 () Int) +(declare-fun si_1__AT1 () Int) +(declare-fun sb_1__AT1 () Bool) +(declare-fun si_2__AT1 () Int) +(declare-fun si_3__AT1 () Int) +(declare-fun sb_2__AT1 () Bool) +(declare-fun si_4__AT1 () Int) +(declare-fun si_5__AT1 () Int) +(declare-fun sb_3__AT1 () Bool) +(declare-fun sb_4__AT1 () Bool) +(declare-fun sb_5__AT1 () Bool) +(declare-fun si_6__AT1 () Int) +(declare-fun si_7__AT1 () Int) +(declare-fun si_8__AT1 () Int) +(declare-fun si_9__AT1 () Int) +(declare-fun si_10__AT1 () Int) +(declare-fun si_11__AT1 () Int) +(declare-fun sb_6__AT1 () Bool) +(declare-fun sb_7__AT1 () Bool) +(declare-fun si_12__AT1 () Int) +(declare-fun si_13__AT1 () Int) +(declare-fun si_14__AT1 () Int) +(assert (let ((.def_163 (= si_0__AT0 si_2__AT1))) +(let ((.def_162 (= si_1__AT0 si_3__AT1))) +(let ((.def_164 (and .def_162 .def_163))) +(let ((.def_155 (* (- 1) si_12__AT1))) +(let ((.def_156 (+ si_1__AT1 .def_155))) +(let ((.def_157 (+ si_0__AT1 .def_156))) +(let ((.def_158 (<= .def_157 0))) +(let ((.def_159 (not .def_158))) +(let ((.def_160 (or sb_5__AT1 .def_159))) +(let ((.def_161 (= sb_2__AT1 .def_160))) +(let ((.def_165 (and .def_161 .def_164))) +(let ((.def_147 (* (- 1) si_7__AT1))) +(let ((.def_148 (+ si_6__AT0 .def_147))) +(let ((.def_149 (= .def_148 (- 1)))) +(let ((.def_142 (not sb_3__AT0))) +(let ((.def_150 (or .def_142 .def_149))) +(let ((.def_144 (= si_7__AT1 0))) +(let ((.def_145 (or sb_3__AT0 .def_144))) +(let ((.def_151 (and .def_145 .def_150))) +(let ((.def_139 (* (- 1) si_13__AT1))) +(let ((.def_140 (+ si_12__AT0 .def_139))) +(let ((.def_141 (= .def_140 (- 1)))) +(let ((.def_143 (or .def_141 .def_142))) +(let ((.def_152 (and .def_143 .def_151))) +(let ((.def_136 (= si_13__AT1 0))) +(let ((.def_137 (or sb_3__AT0 .def_136))) +(let ((.def_153 (and .def_137 .def_152))) +(let ((.def_166 (and .def_153 .def_165))) +(let ((.def_133 (not sb_4__AT0))) +(let ((.def_130 (* (- 1) si_10__AT1))) +(let ((.def_131 (+ si_9__AT0 .def_130))) +(let ((.def_132 (= .def_131 (- 1)))) +(let ((.def_134 (or .def_132 .def_133))) +(let ((.def_126 (= si_10__AT1 0))) +(let ((.def_127 (or sb_4__AT0 .def_126))) +(let ((.def_135 (and .def_127 .def_134))) +(let ((.def_167 (and .def_135 .def_166))) +(let ((.def_125 (= si_7__AT1 si_8__AT1))) +(let ((.def_168 (and .def_125 .def_167))) +(let ((.def_124 (= si_10__AT1 si_11__AT1))) +(let ((.def_169 (and .def_124 .def_168))) +(let ((.def_118 (<= 1 si_0__AT1))) +(let ((.def_117 (<= 1 si_1__AT1))) +(let ((.def_119 (and .def_117 .def_118))) +(let ((.def_114 (<= si_0__AT1 si_6__AT1))) +(let ((.def_115 (not .def_114))) +(let ((.def_116 (or sb_4__AT1 .def_115))) +(let ((.def_120 (and .def_116 .def_119))) +(let ((.def_111 (<= si_1__AT1 si_9__AT1))) +(let ((.def_112 (not .def_111))) +(let ((.def_113 (or sb_5__AT1 .def_112))) +(let ((.def_121 (and .def_113 .def_120))) +(let ((.def_122 (and sb_6__AT0 .def_121))) +(let ((.def_123 (= sb_7__AT1 .def_122))) +(let ((.def_170 (and .def_123 .def_169))) +(let ((.def_110 (= si_13__AT1 si_14__AT1))) +(let ((.def_171 (and .def_110 .def_170))) +(let ((.def_100 (not sb_1__AT1))) +(let ((.def_101 (or sb_2__AT1 .def_100))) +(let ((.def_102 (= sb_0__AT1 .def_101))) +(let ((.def_99 (= si_0__AT1 si_2__AT1))) +(let ((.def_103 (and .def_99 .def_102))) +(let ((.def_98 (= si_1__AT1 si_3__AT1))) +(let ((.def_104 (and .def_98 .def_103))) +(let ((.def_97 (= sb_1__AT1 sb_6__AT1))) +(let ((.def_105 (and .def_97 .def_104))) +(let ((.def_96 (= si_6__AT1 si_8__AT1))) +(let ((.def_106 (and .def_96 .def_105))) +(let ((.def_95 (= si_9__AT1 si_11__AT1))) +(let ((.def_107 (and .def_95 .def_106))) +(let ((.def_94 (= sb_6__AT1 sb_7__AT1))) +(let ((.def_108 (and .def_94 .def_107))) +(let ((.def_93 (= si_12__AT1 si_14__AT1))) +(let ((.def_109 (and .def_93 .def_108))) +(let ((.def_172 (and .def_109 .def_171))) +(let ((.def_173 (and sb_0__AT0 .def_172))) +.def_173 +))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +; (push 1) +; (assert (let ((.def_174 (not sb_0__AT1))) +; .def_174 +; )) +; (check-sat) +; (pop 1) + +(declare-fun sb_0__AT2 () Bool) +(declare-fun si_0__AT2 () Int) +(declare-fun si_1__AT2 () Int) +(declare-fun sb_1__AT2 () Bool) +(declare-fun si_2__AT2 () Int) +(declare-fun si_3__AT2 () Int) +(declare-fun sb_2__AT2 () Bool) +(declare-fun si_4__AT2 () Int) +(declare-fun si_5__AT2 () Int) +(declare-fun sb_3__AT2 () Bool) +(declare-fun sb_4__AT2 () Bool) +(declare-fun sb_5__AT2 () Bool) +(declare-fun si_6__AT2 () Int) +(declare-fun si_7__AT2 () Int) +(declare-fun si_8__AT2 () Int) +(declare-fun si_9__AT2 () Int) +(declare-fun si_10__AT2 () Int) +(declare-fun si_11__AT2 () Int) +(declare-fun sb_6__AT2 () Bool) +(declare-fun sb_7__AT2 () Bool) +(declare-fun si_12__AT2 () Int) +(declare-fun si_13__AT2 () Int) +(declare-fun si_14__AT2 () Int) +(assert (let ((.def_267 (= si_0__AT1 si_2__AT2))) +(let ((.def_266 (= si_1__AT1 si_3__AT2))) +(let ((.def_268 (and .def_266 .def_267))) +(let ((.def_259 (* (- 1) si_12__AT2))) +(let ((.def_260 (+ si_1__AT2 .def_259))) +(let ((.def_261 (+ si_0__AT2 .def_260))) +(let ((.def_262 (<= .def_261 0))) +(let ((.def_263 (not .def_262))) +(let ((.def_264 (or sb_5__AT2 .def_263))) +(let ((.def_265 (= sb_2__AT2 .def_264))) +(let ((.def_269 (and .def_265 .def_268))) +(let ((.def_251 (* (- 1) si_7__AT2))) +(let ((.def_252 (+ si_6__AT1 .def_251))) +(let ((.def_253 (= .def_252 (- 1)))) +(let ((.def_246 (not sb_3__AT1))) +(let ((.def_254 (or .def_246 .def_253))) +(let ((.def_248 (= si_7__AT2 0))) +(let ((.def_249 (or sb_3__AT1 .def_248))) +(let ((.def_255 (and .def_249 .def_254))) +(let ((.def_243 (* (- 1) si_13__AT2))) +(let ((.def_244 (+ si_12__AT1 .def_243))) +(let ((.def_245 (= .def_244 (- 1)))) +(let ((.def_247 (or .def_245 .def_246))) +(let ((.def_256 (and .def_247 .def_255))) +(let ((.def_240 (= si_13__AT2 0))) +(let ((.def_241 (or sb_3__AT1 .def_240))) +(let ((.def_257 (and .def_241 .def_256))) +(let ((.def_270 (and .def_257 .def_269))) +(let ((.def_237 (not sb_4__AT1))) +(let ((.def_234 (* (- 1) si_10__AT2))) +(let ((.def_235 (+ si_9__AT1 .def_234))) +(let ((.def_236 (= .def_235 (- 1)))) +(let ((.def_238 (or .def_236 .def_237))) +(let ((.def_231 (= si_10__AT2 0))) +(let ((.def_232 (or sb_4__AT1 .def_231))) +(let ((.def_239 (and .def_232 .def_238))) +(let ((.def_271 (and .def_239 .def_270))) +(let ((.def_230 (= si_7__AT2 si_8__AT2))) +(let ((.def_272 (and .def_230 .def_271))) +(let ((.def_229 (= si_10__AT2 si_11__AT2))) +(let ((.def_273 (and .def_229 .def_272))) +(let ((.def_223 (<= 1 si_0__AT2))) +(let ((.def_222 (<= 1 si_1__AT2))) +(let ((.def_224 (and .def_222 .def_223))) +(let ((.def_219 (<= si_0__AT2 si_6__AT2))) +(let ((.def_220 (not .def_219))) +(let ((.def_221 (or sb_4__AT2 .def_220))) +(let ((.def_225 (and .def_221 .def_224))) +(let ((.def_216 (<= si_1__AT2 si_9__AT2))) +(let ((.def_217 (not .def_216))) +(let ((.def_218 (or sb_5__AT2 .def_217))) +(let ((.def_226 (and .def_218 .def_225))) +(let ((.def_227 (and sb_6__AT1 .def_226))) +(let ((.def_228 (= sb_7__AT2 .def_227))) +(let ((.def_274 (and .def_228 .def_273))) +(let ((.def_215 (= si_13__AT2 si_14__AT2))) +(let ((.def_275 (and .def_215 .def_274))) +(let ((.def_205 (not sb_1__AT2))) +(let ((.def_206 (or sb_2__AT2 .def_205))) +(let ((.def_207 (= sb_0__AT2 .def_206))) +(let ((.def_204 (= si_0__AT2 si_2__AT2))) +(let ((.def_208 (and .def_204 .def_207))) +(let ((.def_203 (= si_1__AT2 si_3__AT2))) +(let ((.def_209 (and .def_203 .def_208))) +(let ((.def_202 (= sb_1__AT2 sb_6__AT2))) +(let ((.def_210 (and .def_202 .def_209))) +(let ((.def_201 (= si_6__AT2 si_8__AT2))) +(let ((.def_211 (and .def_201 .def_210))) +(let ((.def_200 (= si_9__AT2 si_11__AT2))) +(let ((.def_212 (and .def_200 .def_211))) +(let ((.def_199 (= sb_6__AT2 sb_7__AT2))) +(let ((.def_213 (and .def_199 .def_212))) +(let ((.def_198 (= si_12__AT2 si_14__AT2))) +(let ((.def_214 (and .def_198 .def_213))) +(let ((.def_276 (and .def_214 .def_275))) +(let ((.def_277 (and sb_0__AT1 .def_276))) +.def_277 +))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +(push 1) +(assert (not sb_0__AT2)) +(check-sat) +(pop 1) + diff --git a/test/regress/regress1/simplification_bug4.smt2.expect b/test/regress/regress1/simplification_bug4.smt2.expect new file mode 100644 index 000000000..1ed776c9e --- /dev/null +++ b/test/regress/regress1/simplification_bug4.smt2.expect @@ -0,0 +1,2 @@ +% COMMAND-LINE: --incremental +% EXPECT: unsat diff --git a/test/regress/regress1/sqrt2-sort-inf-unk.smt2 b/test/regress/regress1/sqrt2-sort-inf-unk.smt2 new file mode 100644 index 000000000..f4b15020a --- /dev/null +++ b/test/regress/regress1/sqrt2-sort-inf-unk.smt2 @@ -0,0 +1,6 @@ +; COMMAND-LINE: --sort-inference +; EXPECT: unknown +(set-logic QF_NRA) +(declare-fun x () Real) +(assert (= (* x x) 2.0)) +(check-sat) diff --git a/test/regress/regress1/strings/Makefile.am b/test/regress/regress1/strings/Makefile.am index 716e664b1..8ccf3f81d 100644 --- a/test/regress/regress1/strings/Makefile.am +++ b/test/regress/regress1/strings/Makefile.am @@ -18,9 +18,60 @@ endif # put it below in "TESTS +=" TESTS = \ cmu-5042-0707-2.smt2 \ - cmu-dis-0707-3.smt2 \ - cmu-prereg-fmf.smt2 \ - cmu-repl-len-nterm.smt2 + artemis-0512-nonterm.smt2 \ + bug615.smt2 \ + bug682.smt2 \ + bug686dd.smt2 \ + bug768.smt2 \ + bug799-min.smt2 \ + chapman150408.smt2 \ + cmu-disagree-0707-dd.smt2 \ + cmu-inc-nlpp-071516.smt2 \ + cmu-substr-rw.smt2 \ + crash-1019.smt2 \ + csp-prefix-exp-bug.smt2 \ + fmf001.smt2 \ + fmf002.smt2 \ + idof-nconst-index.smt2 \ + kaluza-fl.smt2 \ + loop007.smt2 \ + loop008.smt2 \ + loop009.smt2 \ + nf-ff-contains-abs.smt2 \ + norn-360.smt2 \ + norn-ab.smt2 \ + norn-nel-bug-052116.smt2 \ + pierre150331.smt2 \ + regexp001.smt2 \ + regexp002.smt2 \ + reloop.smt2 \ + str006.smt2 \ + strings-index-empty.smt2 \ + strip-endpt-sound.smt2 \ + substr001.smt2 \ + type002.smt2 \ + type003.smt2 \ + username_checker_min.smt2 \ + at001.smt2 \ + cmu-2db2-extf-reg.smt2 \ + gm-inc-071516-2.smt2 \ + idof-handg.smt2 \ + idof-neg-index.smt2 \ + idof-triv.smt2 \ + ilc-l-nt.smt2 \ + issue1105.smt2 \ + loop002.smt2 \ + loop003.smt2 \ + loop004.smt2 \ + loop005.smt2 \ + loop006.smt2 \ + norn-simp-rew-sat.smt2 \ + regexp003.smt2 \ + repl-empty-sem.smt2 \ + repl-soundness-sem.smt2 \ + str001.smt2 \ + str002.smt2 \ + str007.smt2 EXTRA_DIST = $(TESTS) diff --git a/test/regress/regress1/strings/artemis-0512-nonterm.smt2 b/test/regress/regress1/strings/artemis-0512-nonterm.smt2 new file mode 100644 index 000000000..4b1cad8f6 --- /dev/null +++ b/test/regress/regress1/strings/artemis-0512-nonterm.smt2 @@ -0,0 +1,26 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status unsat) + +(declare-const Y String) +(assert + (or + (= Y "01") + (= Y "02") + (= Y "03") + (= Y "04") + (= Y "05") + (= Y "06") + (= Y "07") + (= Y "08") + (= Y "09") + (= Y "10") + (= Y "11") + (= Y "12") + ) +) + +(assert (= (<= (str.to.int Y) 31) false)) + +(check-sat) + diff --git a/test/regress/regress1/strings/at001.smt2 b/test/regress/regress1/strings/at001.smt2 new file mode 100644 index 000000000..2ecbcc993 --- /dev/null +++ b/test/regress/regress1/strings/at001.smt2 @@ -0,0 +1,12 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun i () Int) + +(assert (= (str.at x i) "b")) +(assert (and (>= i 4) (< i (str.len x)))) +(assert (< (str.len x) 7)) +(assert (> (str.len x) 2)) + +(check-sat) diff --git a/test/regress/regress1/strings/bug615.smt2 b/test/regress/regress1/strings/bug615.smt2 new file mode 100644 index 000000000..86cc592fb --- /dev/null +++ b/test/regress/regress1/strings/bug615.smt2 @@ -0,0 +1,26 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun s () String) +;(assert (= s "</script><script>alert(1);</script><script>")) + +(declare-fun joined () String) +(assert (= joined (str.++ "<script>console.log('" s "');</script>"))) +(assert (str.contains joined "<script>alert(1);</script>")) + +; (<script>[^<]*</script>)+ +(assert (str.in.re joined + (re.+ (re.++ + (str.to.re "<script>") + (re.* + (re.union + (re.range " " ";") + (re.range "=" "~") + ) + ) + (str.to.re "</script>") + )) + )) + +(check-sat) diff --git a/test/regress/regress1/strings/bug682.smt2 b/test/regress/regress1/strings/bug682.smt2 new file mode 100644 index 000000000..6617b6b97 --- /dev/null +++ b/test/regress/regress1/strings/bug682.smt2 @@ -0,0 +1,19 @@ +; COMMAND-LINE: --incremental --strings-exp +(set-logic QF_S) + +(declare-fun a () String) +(define-fun replace3 ((x String) (y String) (z String)) String (str.replace x y z) ) + +(push 1) +(assert (= (replace3 a "5" "3") "333")) +(assert (str.contains a "5")) +; EXPECT: sat +(check-sat) +(pop 1) + +(push 1) +(assert (= (replace3 a "5" "3") "333")) +(assert (str.contains a "5")) +; EXPECT: sat +(check-sat) +(pop 1) diff --git a/test/regress/regress1/strings/bug686dd.smt2 b/test/regress/regress1/strings/bug686dd.smt2 new file mode 100644 index 000000000..7c923654d --- /dev/null +++ b/test/regress/regress1/strings/bug686dd.smt2 @@ -0,0 +1,13 @@ +(set-logic UFDTSLIA) +(set-info :status sat) + +(declare-datatypes ((T 0)) ( ((TC (TCb String))) ) ) + +(declare-fun root5 () String) +(declare-fun root6 () T) + +(assert (and +(str.in.re root5 (re.loop (re.range "0" "9") 4 4) ) +(str.in.re (TCb root6) (re.loop (re.range "0" "9") 4 4) ) +) ) +(check-sat) diff --git a/test/regress/regress1/strings/bug768.smt2 b/test/regress/regress1/strings/bug768.smt2 new file mode 100644 index 000000000..be3f24200 --- /dev/null +++ b/test/regress/regress1/strings/bug768.smt2 @@ -0,0 +1,10 @@ +(set-logic QF_S) +(set-info :status sat) +(declare-fun f0 () String) +(declare-fun c0 () String) +(declare-fun f1 () String) +(declare-fun f2 () String) + +(assert (= (str.++ f0 f1 f0 c0 f1 c0 f2 f2) "f(,f(c,c))")) + +(check-sat) diff --git a/test/regress/regress1/strings/bug799-min.smt2 b/test/regress/regress1/strings/bug799-min.smt2 new file mode 100644 index 000000000..06acffc97 --- /dev/null +++ b/test/regress/regress1/strings/bug799-min.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --incremental --strings-exp +; EXPECT: sat +(set-logic ALL) +(set-info :status sat) + +(declare-fun u () String) +(declare-fun s () String) + +(assert (= (str.len u) 9)) +(assert (= (str.at u 1) s)) +(assert (= (str.at u 2) "4")) +(assert (= (str.at u 7) "5")) +(assert (= (str.at u 8) "6")) + +(push 1) +(assert (str.in.re s (re.range "0" "3"))) + +(check-sat) diff --git a/test/regress/regress1/strings/chapman150408.smt2 b/test/regress/regress1/strings/chapman150408.smt2 new file mode 100644 index 000000000..f03718556 --- /dev/null +++ b/test/regress/regress1/strings/chapman150408.smt2 @@ -0,0 +1,10 @@ +(set-logic SLIA) +(set-info :status sat) +(set-option :strings-exp true) +(set-option :rewrite-divk true) +(declare-fun string () String) +(assert (and + (and (not (not (not (= (ite (> (str.indexof string ";" 0) 0) 1 0) + 0)))) (not (= (ite (not (= (str.len string) 0)) 1 0) 0))) (not + (not (= (ite (str.contains string "]") 1 0) 0))))) +(check-sat) diff --git a/test/regress/regress1/strings/cmu-2db2-extf-reg.smt2 b/test/regress/regress1/strings/cmu-2db2-extf-reg.smt2 new file mode 100644 index 000000000..b513494b8 --- /dev/null +++ b/test/regress/regress1/strings/cmu-2db2-extf-reg.smt2 @@ -0,0 +1,9 @@ +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun s () String) + +(assert (and (not (not (= (ite (= (str.indexof s "bar" 1) (- 1)) 1 0) 0))) (not (not (= (ite (= (str.indexof s "bar" 1) 3) 1 0) 0))))) + +(check-sat) diff --git a/test/regress/regress1/strings/cmu-dis-0707-3.smt2 b/test/regress/regress1/strings/cmu-dis-0707-3.smt2 deleted file mode 100644 index 3bf47ed61..000000000 --- a/test/regress/regress1/strings/cmu-dis-0707-3.smt2 +++ /dev/null @@ -1,26 +0,0 @@ -; COMMAND-LINE: --lang=smt2.0 -; EXPECT: sat -(set-logic ALL_SUPPORTED) -(set-info :status sat) -(set-option :strings-exp true) -(declare-fun value () String) -(declare-fun name () String) -(assert (not (not (not (= (ite (str.contains value "?") 1 0) 0))))) -(assert (not (not (= (ite (str.contains value "#") 1 0) 0)))) -(assert (not (not (= (ite (= (str.substr value 0 (- 2 0)) "//") 1 0) 0)))) -(assert (not (not (= (ite (> (str.indexof value ":" 0) 0) 1 0) 0)))) -(assert (not (= (ite (not (= (str.len value) 0)) 1 0) 0))) -(assert (not (not (= (ite (str.contains value "'") 1 0) 0)))) -(assert (not (not (= (ite (str.contains value "\"") 1 0) 0)))) -(assert (not (not (= (ite (str.contains value ">") 1 0) 0)))) -(assert (not (not (= (ite (str.contains value "<") 1 0) 0)))) -(assert (not (not (= (ite (str.contains value "&") 1 0) 0)))) -(assert (not (not (= (ite (str.contains name "'") 1 0) 0)))) -(assert (not (not (= (ite (str.contains name "\"") 1 0) 0)))) -(assert (not (not (= (ite (str.contains name ">") 1 0) 0)))) -(assert (not (not (= (ite (str.contains name "<") 1 0) 0)))) -(assert (not (not (= (ite (str.contains name "&") 1 0) 0)))) -(assert (not (= (ite (not (= value "")) 1 0) 0))) -(assert (not (= (ite (str.contains value "javascript:alert(1);") 1 0) 0))) -(assert (not (not (= (ite (str.contains name "javascript:alert(1);") 1 0) 0)))) -(check-sat) diff --git a/test/regress/regress1/strings/cmu-disagree-0707-dd.smt2 b/test/regress/regress1/strings/cmu-disagree-0707-dd.smt2 new file mode 100644 index 000000000..c44dfa396 --- /dev/null +++ b/test/regress/regress1/strings/cmu-disagree-0707-dd.smt2 @@ -0,0 +1,22 @@ +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun url () String) + +(assert +(and +(and +(and +(and + +(= (str.len (str.substr (str.substr url (str.indexof url "#" 2) (- (str.len url) (str.indexof url "#" 2))) (+ (str.indexof (str.substr url (str.indexof url "#" 2) (- (str.len url) (str.indexof url "#" 2))) "#" 0) 1) (- (str.len (str.substr url (str.indexof url "#" 2) (- (str.len url) (str.indexof url "#" 2)))) (+ (str.indexof (str.substr url (str.indexof url "#" 2) (- (str.len url) (str.indexof url "#" 2))) "#" 0) 1)))) 0) + +(not (= (str.substr url 0 (- (str.indexof url ":" 0) 0)) "http"))) +(> (str.indexof url ":" 0) 0)) +(>= (- (str.indexof url "#" 2) 2) 0)) +(>= (str.indexof url ":" 0) 0)) +) + +(check-sat) + diff --git a/test/regress/regress1/strings/cmu-inc-nlpp-071516.smt2 b/test/regress/regress1/strings/cmu-inc-nlpp-071516.smt2 new file mode 100644 index 000000000..1208ca169 --- /dev/null +++ b/test/regress/regress1/strings/cmu-inc-nlpp-071516.smt2 @@ -0,0 +1,9 @@ +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(set-option :strings-exp true) + +(declare-fun url () String) + +(assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (not (= (ite (> (str.indexof url ":" 0) 0) 1 0) 0))) (not (= (ite (str.contains url "javascript:alert(1);") 1 0) 0))) (not (not (= (ite (= (str.len url) 0) 1 0) 0)))) (not (not (= (ite (= (str.at url 0) " ") 1 0) 0)))) (not (not (= (ite (= (str.at url 0) "\t") 1 0) 0)))) (not (not (= (ite (= (str.at url 0) "\n") 1 0) 0)))) (not (not (= (ite (= (str.at url 0) "\r") 1 0) 0)))) (not (not (= (ite (= (str.at url 0) "\v") 1 0) 0)))) (not (not (= (ite (= (str.at url 0) "\f") 1 0) 0)))) (not (not (= (ite (= (str.at url (- (str.len url) 1)) " ") 1 0) 0)))) (not (not (= (ite (= (str.at url (- (str.len url) 1)) "\t") 1 0) 0)))) (not (not (= (ite (= (str.at url (- (str.len url) 1)) "\n") 1 0) 0)))) (not (not (= (ite (= (str.at url (- (str.len url) 1)) "\r") 1 0) 0)))) (not (not (= (ite (= (str.at url (- (str.len url) 1)) "\v") 1 0) 0)))) (not (not (= (ite (= (str.at url (- (str.len url) 1)) "\f") 1 0) 0)))) (not (= (ite (str.prefixof "javascript:alert(1);" url) 1 0) 0)))) + +(check-sat) diff --git a/test/regress/regress1/strings/cmu-prereg-fmf.smt2 b/test/regress/regress1/strings/cmu-prereg-fmf.smt2 deleted file mode 100644 index 0d6827cf7..000000000 --- a/test/regress/regress1/strings/cmu-prereg-fmf.smt2 +++ /dev/null @@ -1,12 +0,0 @@ -; COMMAND-LINE: --strings-exp --strings-fmf -; EXPECT: sat -(set-logic ALL_SUPPORTED) -(set-info :status sat) - -(declare-fun url () String) - -(assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "Y") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "X") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "W") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "V") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "U") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "T") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "S") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "R") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "Q") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "P") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "O") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "N") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "M") 1 0) 0)))) (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) "K" "k") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) "K" "k") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))))) "L") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1))) "K") 1 0) 0)))) (not (= (ite (str.contains (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K") 1 0) 0))) (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K") 1 0) 0))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "J") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "I") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "H") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "G") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "F") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "E") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "D") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "C") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "A") 1 0) 0)))) (not (not (= (ite (not (= (str.len (str.substr url (+ (str.indexof url ":" 0) 1) (- (str.len url) (+ (str.indexof url ":" 0) 1)))) 0)) 1 0) 0)))) (not (not (= (ite (= (str.substr url 0 (- (str.indexof url ":" 0) 0)) "http") 1 0) 0)))) (not (= (ite (> (str.indexof url ":" 0) 0) 1 0) 0))) (not (= (ite (not (= (str.len url) 0)) 1 0) 0))) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1))) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "K" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof url ":" 0) 1) 0)) (>= (- (str.len url) (+ (str.indexof url ":" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0))) - -(check-sat) - -;(get-value (url)) diff --git a/test/regress/regress1/strings/cmu-repl-len-nterm.smt2 b/test/regress/regress1/strings/cmu-repl-len-nterm.smt2 deleted file mode 100644 index 004db77ed..000000000 --- a/test/regress/regress1/strings/cmu-repl-len-nterm.smt2 +++ /dev/null @@ -1,12 +0,0 @@ -; COMMAND-LINE: --strings-exp -; EXPECT: sat -(set-logic ALL_SUPPORTED) -(set-info :status sat) - -(declare-fun url () String) - -(assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (not (not (= (ite (str.contains (str.++ (str.replace (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) 0 (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) "B" "b") (str.++ (str.replace (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) 0 (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1) 0)) "B" "b") (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1))))) "C") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1) (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1))) "B") 1 0) 0)))) (not (= (ite (str.contains (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B") 1 0) 0))) (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B") 1 0) 0))) (not (not (= (ite (str.contains (str.substr url 0 (- (str.indexof url ":" 0) 0)) "A") 1 0) 0)))) (not (not (= (ite (not (= (str.len (str.substr url (+ (str.indexof url ":" 0) 1) (- (str.len url) (+ (str.indexof url ":" 0) 1)))) 0)) 1 0) 0)))) (not (not (= (ite (= (str.substr url 0 (- (str.indexof url ":" 0) 0)) "http") 1 0) 0)))) (not (= (ite (> (str.indexof url ":" 0) 0) 1 0) 0))) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1) 0)) (>= (- (str.len (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)))) (+ (str.indexof (str.substr (str.substr url 0 (- (str.indexof url ":" 0) 0)) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1))) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1) 0)) (>= (- (str.len (str.substr url 0 (- (str.indexof url ":" 0) 0))) (+ (str.indexof (str.substr url 0 (- (str.indexof url ":" 0) 0)) "B" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0)) (>= (+ (str.indexof url ":" 0) 1) 0)) (>= (- (str.len url) (+ (str.indexof url ":" 0) 1)) 0)) (>= 0 0)) (>= (- (str.indexof url ":" 0) 0) 0))) - -(check-sat) - -;(get-value (url)) diff --git a/test/regress/regress1/strings/cmu-substr-rw.smt2 b/test/regress/regress1/strings/cmu-substr-rw.smt2 new file mode 100644 index 000000000..20bf979dd --- /dev/null +++ b/test/regress/regress1/strings/cmu-substr-rw.smt2 @@ -0,0 +1,12 @@ +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(set-option :strings-exp true) +;(set-option :produce-models true) +;(set-option :rewrite-divk true) + +(declare-fun uri () String) + +(assert (and (and (and (and (and (and (and (and (and (and (and (and (not (not (= (ite (= (str.len (str.substr (str.substr uri (+ (str.indexof uri "%" 0) 1) (- (str.len uri) (+ (str.indexof uri "%" 0) 1))) 0 (- 2 0))) 2) 1 0) 0))) (not (not (= (ite (str.contains (str.substr uri (+ (str.indexof uri "%" 0) 1) (- (str.len uri) (+ (str.indexof uri "%" 0) 1))) "%") 1 0) 0)))) (not (not (= (ite (= (str.len (str.substr uri (+ (str.indexof uri "%" 0) 1) (- (str.len uri) (+ (str.indexof uri "%" 0) 1)))) 0) 1 0) 0)))) (not (= (ite (str.contains uri "%") 1 0) 0))) (not (not (= (ite (= (str.len uri) 0) 1 0) 0)))) (>= (+ (str.indexof uri "%" 0) 1) 0)) (>= (- (str.len uri) (+ (str.indexof uri "%" 0) 1)) 0)) (>= 0 0)) (>= (- 2 0) 0)) (>= (+ (str.indexof uri "%" 0) 1) 0)) (>= (- (str.len uri) (+ (str.indexof uri "%" 0) 1)) 0)) (>= (+ (str.indexof uri "%" 0) 1) 0)) (>= (- (str.len uri) (+ (str.indexof uri "%" 0) 1)) 0))) + +(check-sat) + diff --git a/test/regress/regress1/strings/crash-1019.smt2 b/test/regress/regress1/strings/crash-1019.smt2 new file mode 100644 index 000000000..9f2e99b02 --- /dev/null +++ b/test/regress/regress1/strings/crash-1019.smt2 @@ -0,0 +1,10 @@ +(set-logic ALL_SUPPORTED) +(set-option :strings-exp true) +(set-option :rewrite-divk true) +(set-info :status unsat) + +(declare-fun s () String) + +(assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (not (not (= (ite (= (str.++ (str.replace (str.substr s 0 (- (+ (str.indexof s "o" 0) 1) 0)) "o" "a") (str.++ (str.replace (str.substr (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) 0 (- (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1) 0)) "o" "a") (str.substr (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1) (- (str.len (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1)))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1))))) "faa") 1 0) 0)))) (not (not (= (ite (str.contains (str.substr (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1) (- (str.len (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1)))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1))) "o") 1 0) 0)))) (not (= (ite (str.contains (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o") 1 0) 0))) (not (= (ite (str.contains s "o") 1 0) 0))) (>= 0 0)) (> (- (+ (str.indexof s "o" 0) 1) 0) 0)) (> (str.len s) 0)) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= 0 0)) (> (- (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1) 0) 0)) (> (str.len (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1)))) 0)) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1) 0)) (> (- (str.len (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1)))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1)) 0)) (> (str.len (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1)))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1))) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1))) (>= (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1) 0)) (> (- (str.len (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1)))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1)) 0)) (> (str.len (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1)))) (+ (str.indexof (str.substr s (+ (str.indexof s "o" 0) 1) (- (str.len s) (+ (str.indexof s "o" 0) 1))) "o" 0) 1))) (>= (+ (str.indexof s "o" 0) 1) 0)) (> (- (str.len s) (+ (str.indexof s "o" 0) 1)) 0)) (> (str.len s) (+ (str.indexof s "o" 0) 1)))) + +(check-sat) diff --git a/test/regress/regress1/strings/csp-prefix-exp-bug.smt2 b/test/regress/regress1/strings/csp-prefix-exp-bug.smt2 new file mode 100644 index 000000000..c2fb4175c --- /dev/null +++ b/test/regress/regress1/strings/csp-prefix-exp-bug.smt2 @@ -0,0 +1,10 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) + +(assert (= (str.len x) 1)) +(assert (= (str.++ x y "b" z) "aaaba")) +(check-sat) diff --git a/test/regress/regress1/strings/fmf001.smt2 b/test/regress/regress1/strings/fmf001.smt2 new file mode 100644 index 000000000..6081c8e06 --- /dev/null +++ b/test/regress/regress1/strings/fmf001.smt2 @@ -0,0 +1,20 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-option :strings-fmf true) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) + +(assert (str.in.re x + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (str.in.re y + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (not (= x y))) +(assert (= (str.len x) (str.len y))) + +(check-sat) diff --git a/test/regress/regress1/strings/fmf002.smt2 b/test/regress/regress1/strings/fmf002.smt2 new file mode 100644 index 000000000..d52dae2d2 --- /dev/null +++ b/test/regress/regress1/strings/fmf002.smt2 @@ -0,0 +1,17 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-option :strings-fmf true) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) + +(assert (str.in.re x + (re.+ (re.range "a" "c")) + )) + +(assert (= x (str.++ y "c" z "b"))) +(assert (> (str.len z) 1)) + +(check-sat) diff --git a/test/regress/regress1/strings/gm-inc-071516-2.smt2 b/test/regress/regress1/strings/gm-inc-071516-2.smt2 new file mode 100644 index 000000000..1650190f8 --- /dev/null +++ b/test/regress/regress1/strings/gm-inc-071516-2.smt2 @@ -0,0 +1,10 @@ +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(set-option :strings-exp true) + +(declare-fun value2 () String) +(declare-fun key2 () String) + +(assert (and (and (and (and (and (and (not (not (= (ite (str.contains value2 "=") 1 0) 0))) (not (not (= (ite (= (str.len value2) 0) 1 0) 0)))) (not (= (ite (not (= (str.indexof value2 "=" 0) (- 1))) 1 0) 0))) (not (not (= (ite (str.contains value2 ",") 1 0) 0)))) (not (not (= (ite (= (str.len value2) 0) 1 0) 0)))) (not (= (ite (= key2 "cache-control") 1 0) 0))) (not (= (ite (= key2 "cache-control") 1 0) 0)))) + +(check-sat) diff --git a/test/regress/regress1/strings/idof-handg.smt2 b/test/regress/regress1/strings/idof-handg.smt2 new file mode 100644 index 000000000..40aff3168 --- /dev/null +++ b/test/regress/regress1/strings/idof-handg.smt2 @@ -0,0 +1,7 @@ +(set-logic ALL_SUPPORTED) +(set-option :strings-exp true) +(set-info :status sat) +(declare-fun s () String) +(assert (str.contains s "Hello and goodbye!")) +(assert (> (str.indexof s "goodbye" 0) (str.indexof s "Hello" 0))) +(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/strings/idof-nconst-index.smt2 b/test/regress/regress1/strings/idof-nconst-index.smt2 new file mode 100644 index 000000000..eba492220 --- /dev/null +++ b/test/regress/regress1/strings/idof-nconst-index.smt2 @@ -0,0 +1,9 @@ +(set-logic ALL_SUPPORTED) +(set-option :strings-exp true) +(set-info :status sat) +(declare-fun s () String) +(assert (str.contains s "Hello and goodbye!")) +(declare-fun x () Int) +(assert (<= (str.len s) x)) +(assert (not (= (str.indexof s "goodbye" (- x 30)) (- 1)))) +(check-sat) diff --git a/test/regress/regress1/strings/idof-neg-index.smt2 b/test/regress/regress1/strings/idof-neg-index.smt2 new file mode 100644 index 000000000..c24fcc00a --- /dev/null +++ b/test/regress/regress1/strings/idof-neg-index.smt2 @@ -0,0 +1,8 @@ +(set-logic ALL_SUPPORTED) +(set-option :strings-exp true) +(set-info :status unsat) +(declare-fun s () String) +(declare-fun x () Int) +(assert (< x 0)) +(assert (>= (str.indexof s "goodbye" x) 0)) +(check-sat) diff --git a/test/regress/regress1/strings/idof-triv.smt2 b/test/regress/regress1/strings/idof-triv.smt2 new file mode 100644 index 000000000..314adedf8 --- /dev/null +++ b/test/regress/regress1/strings/idof-triv.smt2 @@ -0,0 +1,7 @@ +(set-logic ALL_SUPPORTED) +(set-info :status sat) +(set-option :strings-exp true) +(declare-fun string () String) +;(assert (= string "::")) +(assert (> (str.indexof string ":" 0) 0)) +(check-sat) diff --git a/test/regress/regress1/strings/ilc-l-nt.smt2 b/test/regress/regress1/strings/ilc-l-nt.smt2 new file mode 100644 index 000000000..9e1cc2bc5 --- /dev/null +++ b/test/regress/regress1/strings/ilc-l-nt.smt2 @@ -0,0 +1,14 @@ +(set-logic ALL_SUPPORTED) +(set-info :status unsat) +(set-option :strings-exp true) + +(declare-fun s () String) +(assert (or (= s "Id like cookies.") (= s "Id not like cookies."))) + +(declare-fun target () String) +(assert (or (= target "l") (= target "m"))) + +(declare-fun location () Int) +(assert (= (* 2 location) (str.indexof s target 0))) + +(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/strings/issue1105.smt2 b/test/regress/regress1/strings/issue1105.smt2 new file mode 100644 index 000000000..81e7672da --- /dev/null +++ b/test/regress/regress1/strings/issue1105.smt2 @@ -0,0 +1,10 @@ +(set-logic ALL) +(set-option :strings-exp true) +(set-info :status sat) +(declare-datatype Val ( + (Str (str String)) + (Num (num Int)))) + +(declare-const var0 Val) +(assert (=> (is-Str var0) (distinct (str.to.int (str var0)) (- 1)))) +(check-sat) diff --git a/test/regress/regress1/strings/kaluza-fl.smt2 b/test/regress/regress1/strings/kaluza-fl.smt2 new file mode 100644 index 000000000..04775d61c --- /dev/null +++ b/test/regress/regress1/strings/kaluza-fl.smt2 @@ -0,0 +1,97 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun I0_15 () Int) +(declare-fun I0_18 () Int) +(declare-fun I0_2 () Int) +(declare-fun I0_4 () Int) +(declare-fun I0_6 () Int) +(declare-fun PCTEMP_LHS_1 () Int) +(declare-fun PCTEMP_LHS_2 () Int) +(declare-fun PCTEMP_LHS_3 () Int) +(declare-fun PCTEMP_LHS_4 () Int) +(declare-fun PCTEMP_LHS_5 () Int) +(declare-fun T0_15 () String) +(declare-fun T0_18 () String) +(declare-fun T0_2 () String) +(declare-fun T0_4 () String) +(declare-fun T0_6 () String) +(declare-fun T1_15 () String) +(declare-fun T1_18 () String) +(declare-fun T1_2 () String) +(declare-fun T1_4 () String) +(declare-fun T1_6 () String) +(declare-fun T2_15 () String) +(declare-fun T2_18 () String) +(declare-fun T2_2 () String) +(declare-fun T2_4 () String) +(declare-fun T2_6 () String) +(declare-fun T3_15 () String) +(declare-fun T3_18 () String) +(declare-fun T3_2 () String) +(declare-fun T3_4 () String) +(declare-fun T3_6 () String) +(declare-fun T4_15 () String) +(declare-fun T4_18 () String) +(declare-fun T4_2 () String) +(declare-fun T4_4 () String) +(declare-fun T4_6 () String) +(declare-fun T5_15 () String) +(declare-fun T5_18 () String) +(declare-fun T5_2 () String) +(declare-fun T5_4 () String) +(declare-fun T5_6 () String) +(declare-fun T_4 () Bool) +(declare-fun T_5 () Bool) +(declare-fun T_6 () Bool) +(declare-fun T_7 () Bool) +(declare-fun T_8 () Bool) +(declare-fun T_9 () Bool) +(declare-fun T_SELECT_1 () Bool) +(declare-fun T_SELECT_2 () Bool) +(declare-fun T_SELECT_3 () Bool) +(declare-fun T_SELECT_4 () Bool) +(declare-fun T_SELECT_5 () Bool) +(declare-fun T_a () Bool) +(declare-fun T_c () Bool) +(declare-fun T_e () Bool) +(declare-fun var_0xINPUT_12454 () String) + +(assert (= T_SELECT_1 (not (= PCTEMP_LHS_1 (- 1))))) +(assert (ite T_SELECT_1 + (and (= PCTEMP_LHS_1 (+ I0_2 0))(= var_0xINPUT_12454 (str.++ T0_2 T1_2))(= I0_2 (str.len T4_2))(= 0 (str.len T0_2))(= T1_2 (str.++ T2_2 T3_2))(= T2_2 (str.++ T4_2 T5_2))(= T5_2 "__utma=169413169.")(not (str.in.re T4_2 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "a") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "."))))) + (and (= PCTEMP_LHS_1 (- 1))(= var_0xINPUT_12454 (str.++ T0_2 T1_2))(= 0 (str.len T0_2))(not (str.in.re T1_2 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "a") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "."))))))) +(assert (= T_SELECT_2 (not (= PCTEMP_LHS_2 (- 1))))) +(assert (ite T_SELECT_2 + (and (= PCTEMP_LHS_2 (+ I0_4 0))(= var_0xINPUT_12454 (str.++ T0_4 T1_4))(= I0_4 (str.len T4_4))(= 0 (str.len T0_4))(= T1_4 (str.++ T2_4 T3_4))(= T2_4 (str.++ T4_4 T5_4))(= T5_4 "__utmb=169413169")(not (str.in.re T4_4 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "b") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9"))))) + (and (= PCTEMP_LHS_2 (- 1))(= var_0xINPUT_12454 (str.++ T0_4 T1_4))(= 0 (str.len T0_4))(not (str.in.re T1_4 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "b") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9"))))))) +(assert (= T_SELECT_3 (not (= PCTEMP_LHS_3 (- 1))))) +(assert (ite T_SELECT_3 + (and (= PCTEMP_LHS_3 (+ I0_6 0))(= var_0xINPUT_12454 (str.++ T0_6 T1_6))(= I0_6 (str.len T4_6))(= 0 (str.len T0_6))(= T1_6 (str.++ T2_6 T3_6))(= T2_6 (str.++ T4_6 T5_6))(= T5_6 "__utmc=169413169")(not (str.in.re T4_6 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "c") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9"))))) + (and (= PCTEMP_LHS_3 (- 1))(= var_0xINPUT_12454 (str.++ T0_6 T1_6))(= 0 (str.len T0_6))(not (str.in.re T1_6 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "c") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9"))))))) +(assert (= T_4 (<= 0 PCTEMP_LHS_1))) +(assert T_4) +(assert (= T_5 (<= 0 PCTEMP_LHS_2))) +(assert T_5) +(assert (= T_6 (<= 0 PCTEMP_LHS_3))) +(assert T_6) +(assert (= T_7 (= "" var_0xINPUT_12454))) +(assert (= T_8 (not T_7))) +(assert T_8) +(assert (= T_9 (= var_0xINPUT_12454 ""))) +(assert (= T_a (not T_9))) +(assert T_a) +(assert (= T_SELECT_4 (not (= PCTEMP_LHS_4 (- 1))))) +(assert (ite T_SELECT_4 + (and (= PCTEMP_LHS_4 (+ I0_15 0))(= var_0xINPUT_12454 (str.++ T0_15 T1_15))(= I0_15 (str.len T4_15))(= 0 (str.len T0_15))(= T1_15 (str.++ T2_15 T3_15))(= T2_15 (str.++ T4_15 T5_15))(= T5_15 "__utmb=169413169")(not (str.in.re T4_15 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "b") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9"))))) + (and (= PCTEMP_LHS_4 (- 1))(= var_0xINPUT_12454 (str.++ T0_15 T1_15))(= 0 (str.len T0_15))(not (str.in.re T1_15 (re.++ (str.to.re "_") (str.to.re "_") (str.to.re "u") (str.to.re "t") (str.to.re "m") (str.to.re "b") (str.to.re "=") (str.to.re "1") (str.to.re "6") (str.to.re "9") (str.to.re "4") (str.to.re "1") (str.to.re "3") (str.to.re "1") (str.to.re "6") (str.to.re "9"))))))) +(assert (= T_c (< (- 1) PCTEMP_LHS_4))) +(assert T_c) +(assert (= T_SELECT_5 (not (= PCTEMP_LHS_5 (- 1))))) +(assert (ite T_SELECT_5 + (and (= PCTEMP_LHS_5 (+ I0_18 PCTEMP_LHS_4))(= var_0xINPUT_12454 (str.++ T0_18 T1_18))(= I0_18 (str.len T4_18))(= PCTEMP_LHS_4 (str.len T0_18))(= T1_18 (str.++ T2_18 T3_18))(= T2_18 (str.++ T4_18 T5_18))(= T5_18 ";")(not (str.in.re T4_18 (str.to.re ";")))) + (and (= PCTEMP_LHS_5 (- 1))(= var_0xINPUT_12454 (str.++ T0_18 T1_18))(= PCTEMP_LHS_4 (str.len T0_18))(not (str.in.re T1_18 (str.to.re ";")))))) +(assert (= T_e (< PCTEMP_LHS_5 0))) +(assert T_e) + +(check-sat) diff --git a/test/regress/regress1/strings/loop002.smt2 b/test/regress/regress1/strings/loop002.smt2 new file mode 100644 index 000000000..90492189f --- /dev/null +++ b/test/regress/regress1/strings/loop002.smt2 @@ -0,0 +1,10 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) + +(assert (= (str.++ x "ba") (str.++ "ab" x))) + +(check-sat) diff --git a/test/regress/regress1/strings/loop003.smt2 b/test/regress/regress1/strings/loop003.smt2 new file mode 100644 index 000000000..1247170c9 --- /dev/null +++ b/test/regress/regress1/strings/loop003.smt2 @@ -0,0 +1,13 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun w () String) +(declare-fun w1 () String) +(declare-fun w2 () String) + +(assert (= (str.++ x "aaaae") (str.++ "eaaaa" x))) + +(check-sat) diff --git a/test/regress/regress1/strings/loop004.smt2 b/test/regress/regress1/strings/loop004.smt2 new file mode 100644 index 000000000..8d2ff8096 --- /dev/null +++ b/test/regress/regress1/strings/loop004.smt2 @@ -0,0 +1,13 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun w () String) +(declare-fun w1 () String) +(declare-fun w2 () String) + +(assert (= (str.++ x y z) (str.++ y z x))) + +(check-sat) diff --git a/test/regress/regress1/strings/loop005.smt2 b/test/regress/regress1/strings/loop005.smt2 new file mode 100644 index 000000000..039409ea6 --- /dev/null +++ b/test/regress/regress1/strings/loop005.smt2 @@ -0,0 +1,18 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun w () String) + +;(assert (= (str.++ x y z) (str.++ x z y))) +;(assert (= (str.++ x w z) (str.++ x z w))) + +(assert (= (str.++ y z) (str.++ z y))) +(assert (= (str.++ w z) (str.++ z w))) + +(assert (not (= y w))) +(assert (> (str.len z) 0)) + +(check-sat) diff --git a/test/regress/regress1/strings/loop006.smt2 b/test/regress/regress1/strings/loop006.smt2 new file mode 100644 index 000000000..288a5f60c --- /dev/null +++ b/test/regress/regress1/strings/loop006.smt2 @@ -0,0 +1,15 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun w () String) +(declare-fun w1 () String) +(declare-fun w2 () String) + +;(assert (= (str.++ x y) (str.++ y x))) + +(assert (not (= (str.++ x y) (str.++ y x)))) + +(check-sat) diff --git a/test/regress/regress1/strings/loop007.smt2 b/test/regress/regress1/strings/loop007.smt2 new file mode 100644 index 000000000..a97d97d54 --- /dev/null +++ b/test/regress/regress1/strings/loop007.smt2 @@ -0,0 +1,12 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) + +(assert (= (str.++ x y "aa") (str.++ "aa" y x))) +(assert (= (str.len x) (* 2 (str.len y)))) +(assert (> (str.len x) 0)) + +(check-sat) diff --git a/test/regress/regress1/strings/loop008.smt2 b/test/regress/regress1/strings/loop008.smt2 new file mode 100644 index 000000000..f84ba442b --- /dev/null +++ b/test/regress/regress1/strings/loop008.smt2 @@ -0,0 +1,10 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun x () String) + +(assert (= (str.++ x "ab") (str.++ "ba" x))) +(assert (> (str.len x) 5)) + +(check-sat) diff --git a/test/regress/regress1/strings/loop009.smt2 b/test/regress/regress1/strings/loop009.smt2 new file mode 100644 index 000000000..30fc6cebc --- /dev/null +++ b/test/regress/regress1/strings/loop009.smt2 @@ -0,0 +1,10 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun x () String) + +(assert (= (str.++ x "aa") (str.++ "aa" x))) +(assert (= (str.len x) 7)) + +(check-sat) diff --git a/test/regress/regress1/strings/nf-ff-contains-abs.smt2 b/test/regress/regress1/strings/nf-ff-contains-abs.smt2 new file mode 100644 index 000000000..eb6792666 --- /dev/null +++ b/test/regress/regress1/strings/nf-ff-contains-abs.smt2 @@ -0,0 +1,15 @@ +(set-logic QF_S) +(set-info :status unsat) +(declare-fun a () String) +(declare-fun b () String) +(declare-fun c () String) +(declare-fun d () String) +(declare-fun e () String) +(declare-fun f () String) +(declare-fun g () String) +(assert (= (str.++ "abc" a "def" b "gg" c) (str.++ e g f))) +(assert (or (= a "a") (= a "aaa"))) +(assert (or (= b "b") (= b "bbb"))) +(assert (or (= c "c") (= c "ccc"))) +(assert (or (= g (str.++ ";" d)) (= g (str.++ d ";")))) +(check-sat) diff --git a/test/regress/regress1/strings/norn-360.smt2 b/test/regress/regress1/strings/norn-360.smt2 new file mode 100644 index 000000000..573dcbe01 --- /dev/null +++ b/test/regress/regress1/strings/norn-360.smt2 @@ -0,0 +1,25 @@ +(set-logic QF_SLIA) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun var_0 () String) +(declare-fun var_1 () String) +(declare-fun var_2 () String) +(declare-fun var_3 () String) +(declare-fun var_4 () String) +(declare-fun var_5 () String) +(declare-fun var_6 () String) +(declare-fun var_7 () String) +(declare-fun var_8 () String) +(declare-fun var_9 () String) +(declare-fun var_10 () String) +(declare-fun var_11 () String) +(declare-fun var_12 () String) + +(assert (str.in.re (str.++ var_3 "z" var_4 ) (re.++ (re.* (re.union (re.union (str.to.re "z") (str.to.re "b")) (re.++ (str.to.re "a") (re.union (re.union (str.to.re "z") (str.to.re "b")) (str.to.re "a"))))) (str.to.re "a")))) +(assert (str.in.re (str.++ var_3 "z" var_4 ) (re.++ (re.* (re.union (re.union (str.to.re "z") (str.to.re "b")) (re.++ (str.to.re "a") (re.union (str.to.re "z") (str.to.re "a"))))) (str.to.re "a")))) +(assert (str.in.re (str.++ var_3 "z" var_4 ) (re.++ (re.* (re.union (str.to.re "z") (re.++ (re.union (str.to.re "b") (str.to.re "a")) (re.union (str.to.re "z") (str.to.re "b"))))) (re.union (str.to.re "b") (str.to.re "a"))))) +(assert (str.in.re var_4 (re.* (re.range "a" "u")))) +(assert (str.in.re var_3 (re.* (re.range "a" "u")))) +(assert (<= 0 (str.len var_4))) +(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/strings/norn-ab.smt2 b/test/regress/regress1/strings/norn-ab.smt2 new file mode 100644 index 000000000..48d889847 --- /dev/null +++ b/test/regress/regress1/strings/norn-ab.smt2 @@ -0,0 +1,25 @@ +(set-logic QF_SLIA) +(set-info :status unsat) +(set-option :strings-exp true) + +(declare-fun var_0 () String) +(declare-fun var_1 () String) +(declare-fun var_2 () String) +(declare-fun var_3 () String) +(declare-fun var_4 () String) +(declare-fun var_5 () String) +(declare-fun var_6 () String) +(declare-fun var_7 () String) +(declare-fun var_8 () String) +(declare-fun var_9 () String) +(declare-fun var_10 () String) +(declare-fun var_11 () String) +(declare-fun var_12 () String) + +(assert (str.in.re var_4 (re.++ (str.to.re "a") (re.* (str.to.re "b"))))) +(assert (str.in.re var_4 (re.++ (re.* (str.to.re "a")) (str.to.re "b")))) +(assert (str.in.re var_4 (re.* (re.range "a" "u")))) +(assert (str.in.re var_4 (re.++ (re.* (str.to.re "a")) (re.++ (str.to.re "b") (re.* (str.to.re "b")))))) +(assert (not (str.in.re (str.++ "a" var_4 "b" ) (re.++ (re.* (str.to.re "a")) (re.++ (str.to.re "b") (re.* (str.to.re "b"))))))) +(assert (and (<= 0 (str.len var_4)) (not (not (exists ((v Int)) (= (* v 2 ) (+ (str.len var_4) 2 ))))))) +(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/strings/norn-nel-bug-052116.smt2 b/test/regress/regress1/strings/norn-nel-bug-052116.smt2 new file mode 100644 index 000000000..f0c2534a1 --- /dev/null +++ b/test/regress/regress1/strings/norn-nel-bug-052116.smt2 @@ -0,0 +1,23 @@ +(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun var_0 () String) +(declare-fun var_1 () String) +(declare-fun var_2 () String) +(declare-fun var_3 () String) +(declare-fun var_4 () String) +(declare-fun var_5 () String) +(declare-fun var_6 () String) +(declare-fun var_7 () String) +(declare-fun var_8 () String) +(declare-fun var_9 () String) +(declare-fun var_10 () String) +(declare-fun var_11 () String) +(declare-fun var_12 () String) + +(assert (str.in.re var_4 (re.* (re.range "a" "u")))) +(assert (str.in.re var_4 (re.++ (re.* (re.union (str.to.re "a") (re.++ (str.to.re "b") (str.to.re "a")))) (str.to.re "b")))) +(assert (str.in.re (str.++ "a" var_4 "b" ) (re.* (re.range "a" "u")))) +(assert (not (str.in.re (str.++ "a" var_4 "b" ) (re.++ (re.* (str.to.re "a")) (re.++ (str.to.re "b") (re.* (str.to.re "b"))))))) +(check-sat) diff --git a/test/regress/regress1/strings/norn-simp-rew-sat.smt2 b/test/regress/regress1/strings/norn-simp-rew-sat.smt2 new file mode 100644 index 000000000..01a102bf9 --- /dev/null +++ b/test/regress/regress1/strings/norn-simp-rew-sat.smt2 @@ -0,0 +1,25 @@ +(set-logic QF_SLIA) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun var_0 () String) +(declare-fun var_1 () String) +(declare-fun var_2 () String) +(declare-fun var_3 () String) +(declare-fun var_4 () String) +(declare-fun var_5 () String) +(declare-fun var_6 () String) +(declare-fun var_7 () String) +(declare-fun var_8 () String) +(declare-fun var_9 () String) +(declare-fun var_10 () String) +(declare-fun var_11 () String) +(declare-fun var_12 () String) + +(assert (str.in.re (str.++ var_3 "z" var_4 ) (re.++ (re.* (re.union (re.union (str.to.re "z") (str.to.re "a")) (re.++ (str.to.re "b") (re.++ (re.* (str.to.re "b")) (re.union (str.to.re "z") (str.to.re "a")))))) (re.++ (str.to.re "b") (re.* (str.to.re "b")))))) +(assert (str.in.re var_4 (re.* (re.range "a" "u")))) +(assert (str.in.re var_4 (re.* (str.to.re "b")))) +(assert (str.in.re var_3 (re.* (re.range "a" "u")))) +(assert (str.in.re var_3 (re.* (str.to.re "a")))) +(assert (<= 0 (str.len var_4))) +(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/strings/pierre150331.smt2 b/test/regress/regress1/strings/pierre150331.smt2 new file mode 100644 index 000000000..88d5ec10c --- /dev/null +++ b/test/regress/regress1/strings/pierre150331.smt2 @@ -0,0 +1,13 @@ +(set-logic SLIA)
+(set-info :status sat)
+(set-info :smt-lib-version 2.5)
+(set-option :strings-exp true)
+(define-fun stringEval ((?s String)) Bool (str.in.re ?s
+(re.union
+(str.to.re "H")
+(re.++ (re.loop (str.to.re "{") 2 2 ) (re.loop (re.union re.nostr (re.range " " "]") (re.range "" "^") ) 2 4 ) ) ) ) )
+(declare-fun s0() String)
+(declare-fun s1() String)
+(declare-fun s2() String)
+(assert (and true (stringEval s0) (stringEval s1) (distinct s0 s1) (stringEval s2) (distinct s0 s2) (distinct s1 s2) ) )
+(check-sat)
\ No newline at end of file diff --git a/test/regress/regress1/strings/regexp001.smt2 b/test/regress/regress1/strings/regexp001.smt2 new file mode 100644 index 000000000..62c142d1d --- /dev/null +++ b/test/regress/regress1/strings/regexp001.smt2 @@ -0,0 +1,13 @@ +(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun x () String) + +(assert (str.in.re x + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (= (str.len x) 3)) + +(check-sat) diff --git a/test/regress/regress1/strings/regexp002.smt2 b/test/regress/regress1/strings/regexp002.smt2 new file mode 100644 index 000000000..a8bd2187a --- /dev/null +++ b/test/regress/regress1/strings/regexp002.smt2 @@ -0,0 +1,24 @@ +(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) +; this option requires user to check whether the constraint is in the fragment +; currently we do not provide only positive membership constraint checking +; if users use this option but the constraint is not in this fragment, the result will fail +(set-option :strings-inm true) + +(declare-fun x () String) +(declare-fun y () String) + +(assert (str.in.re x + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (str.in.re y + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (not (= x y))) +(assert (= (str.len x) (str.len y))) +(assert (= (str.len y) 3)) + +(check-sat) diff --git a/test/regress/regress1/strings/regexp003.smt2 b/test/regress/regress1/strings/regexp003.smt2 new file mode 100644 index 000000000..7696838fe --- /dev/null +++ b/test/regress/regress1/strings/regexp003.smt2 @@ -0,0 +1,13 @@ +(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-const s String) + +(assert (str.in.re s (re.inter + (re.++ (str.to.re "a") (re.* (str.to.re "b")) + (re.inter (str.to.re "c") (re.* (str.to.re "c")))) + (re.++ (str.to.re "a") (re.* (str.to.re "b")) (re.* (str.to.re "c"))) + ))) + +(check-sat) diff --git a/test/regress/regress1/strings/reloop.smt2 b/test/regress/regress1/strings/reloop.smt2 new file mode 100644 index 000000000..9915504ae --- /dev/null +++ b/test/regress/regress1/strings/reloop.smt2 @@ -0,0 +1,18 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun w () String) + +(assert (str.in.re x (re.loop (str.to.re "a") 5))) +(assert (str.in.re y (re.loop (str.to.re "b") 2 5))) +(assert (str.in.re z (re.loop (str.to.re "c") 5))) +(assert (> (str.len z) 7)) +(assert (str.in.re w (re.loop (str.to.re "b") 2 7))) +(assert (> (str.len w) 2)) +(assert (< (str.len w) 5)) + +(check-sat) diff --git a/test/regress/regress1/strings/repl-empty-sem.smt2 b/test/regress/regress1/strings/repl-empty-sem.smt2 new file mode 100644 index 000000000..61f70bc23 --- /dev/null +++ b/test/regress/regress1/strings/repl-empty-sem.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --strings-exp +; EXPECT: unsat +(set-logic ALL) +(set-info :status unsat) +(declare-fun x () String) +(declare-fun z () String) +(assert (= (str.len z) 0)) +(assert (= (str.replace "ab" z "c") x)) +(declare-fun y () String) +(assert (= x (str.++ "c" y))) +(check-sat) diff --git a/test/regress/regress1/strings/repl-soundness-sem.smt2 b/test/regress/regress1/strings/repl-soundness-sem.smt2 new file mode 100644 index 000000000..d56d7945f --- /dev/null +++ b/test/regress/regress1/strings/repl-soundness-sem.smt2 @@ -0,0 +1,12 @@ +; COMMAND-LINE: --strings-exp +; EXPECT: sat +(set-logic ALL) +(set-info :status sat) +(declare-fun x () String) +(declare-fun y () String) +(assert (and +(= (str.replace x x "abc") "") +(= (str.replace (str.++ x y) x "abc") (str.++ x y)) +(= (str.replace (str.++ x y) (str.substr x 0 2) "abc") y) +)) +(check-sat) diff --git a/test/regress/regress1/strings/str001.smt2 b/test/regress/regress1/strings/str001.smt2 new file mode 100644 index 000000000..bb2b701d8 --- /dev/null +++ b/test/regress/regress1/strings/str001.smt2 @@ -0,0 +1,16 @@ +(set-logic QF_S) +(set-info :status unsat) + +(declare-fun xx () String) +(declare-fun yy () String) +(declare-fun zz () String) +(declare-fun ww () String) +(declare-fun pp () String) +(declare-fun qq () String) + +(assert (= (str.++ xx yy zz) (str.++ ww qq))) +(assert (= ww (str.++ xx pp))) +(assert (= yy pp)) +(assert (not (= zz qq))) + +(check-sat) diff --git a/test/regress/regress1/strings/str002.smt2 b/test/regress/regress1/strings/str002.smt2 new file mode 100644 index 000000000..62512ef79 --- /dev/null +++ b/test/regress/regress1/strings/str002.smt2 @@ -0,0 +1,18 @@ +(set-logic QF_S) +(set-info :status unsat) + +(declare-fun xx () String) +(declare-fun yy () String) +(declare-fun zz () String) +(declare-fun ww () String) +(declare-fun pp () String) +(declare-fun qq () String) + +; assoc +(assert (or (= xx (str.++ yy "aa")) (= zz (str.++ yy "aa")) +)) +(assert (and (not (= (str.++ xx "bb") (str.++ yy "aa" "bb"))) + (not (= (str.++ zz "bb") (str.++ yy "aa" "bb"))) +)) + +(check-sat) diff --git a/test/regress/regress1/strings/str006.smt2 b/test/regress/regress1/strings/str006.smt2 new file mode 100644 index 000000000..2bdf9b1b5 --- /dev/null +++ b/test/regress/regress1/strings/str006.smt2 @@ -0,0 +1,14 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) + +;plandowski p469 1 +(assert (= (str.++ x "ab" y) (str.++ y "ba" z))) +(assert (= z (str.++ x y))) +(assert (not (= (str.++ x "a") (str.++ "a" x)))) + +(check-sat) + diff --git a/test/regress/regress1/strings/str007.smt2 b/test/regress/regress1/strings/str007.smt2 new file mode 100644 index 000000000..a7173701a --- /dev/null +++ b/test/regress/regress1/strings/str007.smt2 @@ -0,0 +1,13 @@ +(set-logic QF_S) +(set-info :status unsat) + +(declare-fun x () String) +(declare-fun y () String) + + +(assert (or (= x y) (= x y))) + +(assert (= (str.++ x "ba") (str.++ "ab" x))) +(assert (= (str.++ y "ab") (str.++ "ab" y))) + +(check-sat) diff --git a/test/regress/regress1/strings/strings-index-empty.smt2 b/test/regress/regress1/strings/strings-index-empty.smt2 new file mode 100644 index 000000000..a726d9cab --- /dev/null +++ b/test/regress/regress1/strings/strings-index-empty.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --simplification=none --strings-exp --no-strings-lazy-pp +; EXPECT: sat +(set-logic SLIA) +(set-info :status sat) +(declare-fun x () String) +(declare-fun f () String) +(declare-fun y () Int) +(assert (= (str.len f) 0)) +; command line options ensure reduction is invoked for indexof, f is "", should return -1 +(assert (= (str.indexof x f 4) y)) +(check-sat) diff --git a/test/regress/regress1/strings/strip-endpt-sound.smt2 b/test/regress/regress1/strings/strip-endpt-sound.smt2 new file mode 100644 index 000000000..0c1dd123c --- /dev/null +++ b/test/regress/regress1/strings/strip-endpt-sound.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --strings-exp +; EXPECT: sat +(set-logic QF_S) +(declare-fun x () String) +(declare-fun y () String) + +(assert (str.contains "c(ab)" (str.++ x ")"))) +(assert (str.contains "c(ab)" (str.++ "c(" y))) + +(declare-fun z () String) +(declare-fun w () String) + +(assert (str.contains "c(ab))" (str.++ z "))"))) +(assert (str.contains z "b")) + +(assert (str.contains "c(ab))" (str.++ w "b)"))) +(assert (str.contains w "a")) + + +(declare-fun p () String) +(declare-fun q () String) + +(assert (str.contains "c(aab))" (str.++ "a" p))) +(assert (str.contains p "a")) + +(assert (str.contains "c(abb))" (str.++ q "b"))) +(assert (str.contains q "b")) + +(check-sat) diff --git a/test/regress/regress1/strings/substr001.smt2 b/test/regress/regress1/strings/substr001.smt2 new file mode 100644 index 000000000..78f3ffee7 --- /dev/null +++ b/test/regress/regress1/strings/substr001.smt2 @@ -0,0 +1,16 @@ +(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun i1 () Int) +(declare-fun i2 () Int) +(declare-fun i3 () Int) +(declare-fun i4 () Int) + +(assert (and (>= i1 0) (>= i2 0) (< (+ i1 i2) (str.len x)))) +(assert (and (>= i3 0) (>= i4 0) (< (+ i3 i4) (str.len x)))) +(assert (= "efg" (str.substr x i1 i2) ) ) +(assert (= "bef" (str.substr x i3 i4) ) ) +(assert (> (str.len x) 5)) + +(check-sat) diff --git a/test/regress/regress1/strings/type002.smt2 b/test/regress/regress1/strings/type002.smt2 new file mode 100644 index 000000000..0df0f20b0 --- /dev/null +++ b/test/regress/regress1/strings/type002.smt2 @@ -0,0 +1,18 @@ +(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun i () Int) + +(assert (>= i 420)) +(assert (= x (int.to.str i))) +(assert (= x (str.++ y "0" z))) +(assert (not (= y ""))) +(assert (not (= z ""))) + + + +(check-sat) diff --git a/test/regress/regress1/strings/type003.smt2 b/test/regress/regress1/strings/type003.smt2 new file mode 100644 index 000000000..c2d4792cc --- /dev/null +++ b/test/regress/regress1/strings/type003.smt2 @@ -0,0 +1,12 @@ +(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun i () Int) +(declare-fun s () String) + +(assert (< 67 (str.to.int s))) +(assert (= (str.len s) 2)) +(assert (not (= s "68"))) + +(check-sat) diff --git a/test/regress/regress1/strings/username_checker_min.smt2 b/test/regress/regress1/strings/username_checker_min.smt2 new file mode 100644 index 000000000..2f1c35844 --- /dev/null +++ b/test/regress/regress1/strings/username_checker_min.smt2 @@ -0,0 +1,14 @@ +(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status unsat) + +(declare-const buff String) +(declare-const pass_mem String) +(assert (= (str.len buff) 4)) +(assert (= (str.len pass_mem) 1)) + +(assert (str.in.re (str.++ buff pass_mem) (re.+ (str.to.re "A")))) + +(assert (str.contains buff "<")) + +(check-sat) diff --git a/test/regress/regress1/sygus/Base16_1.sy b/test/regress/regress1/sygus/Base16_1.sy new file mode 100644 index 000000000..b54c7688b --- /dev/null +++ b/test/regress/regress1/sygus/Base16_1.sy @@ -0,0 +1,34 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-qe-preproc --cbqi-full --sygus-out=status --cegqi-si=all +(set-logic BV) + +(define-fun B ((h (BitVec 8)) (l (BitVec 8)) (v (BitVec 8))) (BitVec 8) (bvlshr (bvshl v (bvsub #x07 h)) (bvsub #x07 (bvsub h l)))) + +(define-fun E ((x (BitVec 8))) (BitVec 8) (bvadd x #x41)) + +(define-fun f ((x (BitVec 8))) (BitVec 8) (bvsub x #x41)) + +(define-fun d ((x (BitVec 8))) Bool (bvule x #x3f)) + +(synth-fun D ((x (BitVec 8)) (y (BitVec 8)) ) (BitVec 8) + ((Start (BitVec 8) ( + (f Start) x y Const + (bvshl Start Start) (bvnot Start) + (bvand Start Start) + (bvxor Start Start) + (bvor Start Start) + (bvneg Start) + (bvadd Start Start) + (bvlshr Start Start) + (bvsub Start Start) + )) + (Const (BitVec 8) (#x01 #x03 #x06 #x07 #x04 #x05 #x02 #x00)) +)) + +(declare-var x (BitVec 8)) +(constraint (= x (D (E (B #x07 #x04 x) ) (E (B #x03 #x00 x)) )) ) + +; notice we don't have solution reconstruction for this +(check-synth) + + diff --git a/test/regress/regress1/sygus/MPwL_d1s3.sy b/test/regress/regress1/sygus/MPwL_d1s3.sy deleted file mode 100644 index 5178cf86b..000000000 --- a/test/regress/regress1/sygus/MPwL_d1s3.sy +++ /dev/null @@ -1,151 +0,0 @@ -; EXPECT: unsat -; COMMAND-LINE: --sygus-out=status -(set-logic LIA) - -(define-fun get-y ((currPoint Int)) Int -(ite (< currPoint 10) 0 (ite (< currPoint 20) 1 (ite (< currPoint 30) 2 (ite (< currPoint 40) 3 (ite (< currPoint 50) 4 (ite (< currPoint 60) 5 (ite (< currPoint 70) 6 (ite (< currPoint 80) 7 (ite (< currPoint 90) 8 9)))))))))) - -(define-fun get-x ((currPoint Int)) Int - (- currPoint (* (get-y currPoint) 10))) -(define-fun interpret-move (( currPoint Int ) ( move Int)) Int -(ite (= move 0) currPoint -(ite (= move 1) (ite (or (< (+ (get-y currPoint) 1) 0) (>= (+ (get-y currPoint) 1) 10)) currPoint (+ currPoint 10)) -(ite (= move 2) (ite (or (< (+ (get-x currPoint) 1) 0) (>= (+ (get-x currPoint) 1) 10)) currPoint (+ currPoint 1)) -(ite (= move 3) (ite (or (< (+ (get-y currPoint) -1) 0) (>= (+ (get-y currPoint) -1) 10)) currPoint (+ currPoint -10)) -(ite (= move 4) (ite (or (< (+ (get-x currPoint) -1) 0) (>= (+ (get-x currPoint) -1) 10)) currPoint (+ currPoint -1)) -currPoint)))))) - -(define-fun interpret-move-obstacle-0 (( currPoint Int ) ( move Int)) Int -(ite (= move 0) (ite (or (< (+ (get-y currPoint) 1) 0) (>= (+ (get-y currPoint) 1) 10)) currPoint (+ currPoint 10)) -(ite (= move 1) (ite (or (< (+ (get-y currPoint) -1) 0) (>= (+ (get-y currPoint) -1) 10)) currPoint (+ currPoint -10)) -currPoint))) - -(define-fun interpret-move-obstacle-1 (( currPoint Int ) ( move Int)) Int -(ite (= move 0) (ite (or (< (+ (get-y currPoint) 1) 0) (>= (+ (get-y currPoint) 1) 10)) currPoint (+ currPoint 10)) -(ite (= move 1) currPoint -(ite (= move 2) (ite (or (< (+ (get-y currPoint) -1) 0) (>= (+ (get-y currPoint) -1) 10)) currPoint (+ currPoint -10)) -currPoint)))) - -(define-fun allowable-move-obstacle-0 (( start Int ) ( end Int)) Bool - (or (= (interpret-move-obstacle-0 start 0) end) - (or (= (interpret-move-obstacle-0 start 1) end) false))) - -(define-fun allowable-move-obstacle-1 (( start Int ) ( end Int)) Bool - (or (= (interpret-move-obstacle-1 start 0) end) - (or (= (interpret-move-obstacle-1 start 1) end) - (or (= (interpret-move-obstacle-1 start 2) end) false)))) - -(define-fun get-move-obstacle-0 (( start Int ) ( end Int)) Int - (ite (= (interpret-move-obstacle-0 start 0) end) 0 - (ite (= (interpret-move-obstacle-0 start 1) end) 1 -1))) - -(define-fun get-move-obstacle-1 (( start Int ) ( end Int)) Int - (ite (= (interpret-move-obstacle-1 start 0) end) 0 - (ite (= (interpret-move-obstacle-1 start 1) end) 1 - (ite (= (interpret-move-obstacle-1 start 2) end) 2 -1)))) - -(define-fun no-overlap-one-move-combination-2-2 ((p0 Int) (p1 Int) (p2 Int) (p3 Int)) Bool - (and (not (= p0 p2)) (and (not (= p0 p3)) (and (not (= p1 p2)) (and (not (= p1 p3)) true))))) - -(define-fun no-overlaps-0 (( currPoint Int ) ( move Int) (obstacleCurrPoint Int) (obstacleMove Int)) Bool - (= 1 - (ite (= move 0) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0)) - (ite (= move 1) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0)) - (ite (= move 2) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0)) - (ite (= move 3) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) -10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) -10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0)) - (ite (= move 4) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint -1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint -1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0)) 0))))))) - -(define-fun no-overlaps-1 (( currPoint Int ) ( move Int) (obstacleCurrPoint Int) (obstacleMove Int)) Bool - (= 1 - (ite (= move 0) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 0)) 1 0) - (ite (= obstacleMove 2) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0))) - (ite (= move 1) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 0)) 1 0) - (ite (= obstacleMove 2) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) 10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0))) - (ite (= move 2) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 0)) 1 0) - (ite (= obstacleMove 2) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0))) - (ite (= move 3) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) -10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) -10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 0)) 1 0) - (ite (= obstacleMove 2) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint 0) -10) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0))) - (ite (= move 4) - (ite (= obstacleMove 0) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint -1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 10)) 1 0) - (ite (= obstacleMove 1) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint -1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) 0)) 1 0) - (ite (= obstacleMove 2) (ite (no-overlap-one-move-combination-2-2 currPoint (+ (+ currPoint -1) 0) obstacleCurrPoint (+ (+ obstacleCurrPoint 0) -10)) 1 0) 0))) 0))))))) - -(define-fun no-overlaps-one-step-helper ((currPoint Int) (move Int) (o0-t Int) (o0move Int) (o1-t Int) (o1move Int)) Bool - (and (no-overlaps-0 currPoint move o0-t o0move) (and (no-overlaps-1 currPoint move o1-t o1move) true))) - -(define-fun no-overlaps-one-step ((currPoint Int) (move Int) (o0-0 Int) (o0-1 Int) (o1-0 Int) (o1-1 Int)) Bool - (no-overlaps-one-step-helper currPoint move o0-0 (get-move-obstacle-0 o0-0 o0-1) o1-0 (get-move-obstacle-1 o1-0 o1-1))) - - - -(declare-var o0-1 Int) -(declare-var o0-2 Int) -(declare-var o0-3 Int) -(declare-var o1-1 Int) -(declare-var o1-2 Int) -(declare-var o1-3 Int) - -(synth-fun move ((currPoint Int) (o0 Int) (o1 Int)) Int - ((Start Int ( - MoveId - (ite StartBool Start Start))) - (MoveId Int (0 - 1 - 2 - 3 - 4 - )) - (CondInt Int ( - (get-y currPoint) ;y coord - (get-x currPoint) ;x coord - (get-y o0) - (get-x o0) - (get-y o1) - (get-x o1) - (+ CondInt CondInt) - (- CondInt CondInt) - -1 - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - )) - (StartBool Bool ((and StartBool StartBool) - (or StartBool StartBool) - (not StartBool) - (<= CondInt CondInt) - (= CondInt CondInt) - (>= CondInt CondInt))))) - - (constraint (let ((pos0 Int 0)) (let ((mov0 Int (move pos0 99 98))) (let ((pos1 Int (interpret-move pos0 mov0))) (let ((mov1 Int (move pos1 o0-1 o1-1))) (let ((pos2 Int (interpret-move pos1 mov1))) (let ((mov2 Int (move pos2 o0-2 o1-2))) (let ((pos3 Int (interpret-move pos2 mov2))) - (or - (and - (= pos3 30) - (and (no-overlaps-one-step pos0 mov0 99 o0-1 98 o1-1) (and (no-overlaps-one-step pos1 mov1 o0-1 o0-2 o1-1 o1-2) (and (no-overlaps-one-step pos2 mov2 o0-2 o0-3 o1-2 o1-3) true)))) - (not (and (allowable-move-obstacle-0 99 o0-1) (and (allowable-move-obstacle-0 o0-1 o0-2) (and (allowable-move-obstacle-0 o0-2 o0-3) (and (allowable-move-obstacle-1 98 o1-1) (and (allowable-move-obstacle-1 o1-1 o1-2) (and (allowable-move-obstacle-1 o1-2 o1-3) true)))))))))))))))) - -(check-synth) diff --git a/test/regress/regress1/sygus/Makefile.am b/test/regress/regress1/sygus/Makefile.am index b2a428bd1..c44c5034d 100644 --- a/test/regress/regress1/sygus/Makefile.am +++ b/test/regress/regress1/sygus/Makefile.am @@ -16,23 +16,61 @@ endif # These are run for all build profiles. # If a test shouldn't be run in e.g. competition mode, # put it below in "TESTS +=" -TESTS = \ +TESTS = \ hd-sdiv.sy \ stopwatch-bt.sy \ - array_sum_dd.sy \ - mpg_guard1-dd.sy \ VC22_a.sy \ - inv_gen_n_c11.sy \ unbdd_inv_gen_ex7.sy \ - icfp_easy_mt_ite.sy \ - three.sy \ - nia-max-square.sy \ - MPwL_d1s3.sy \ - process-arg-invariance.sy \ real-grammar.sy \ - lustre-real.sy + cegar1.sy \ + cggmp.sy \ + clock-inc-tuple.sy \ + dup-op.sy \ + fg_polynomial3.sy \ + hd-01-d1-prog.sy \ + icfp_14.12.sy \ + icfp_14.12-flip-args.sy \ + icfp_28_10.sy \ + icfp_easy-ite.sy \ + inv-example.sy \ + inv-unused.sy \ + multi-fun-polynomial2.sy \ + no-flat-simp.sy \ + process-10-vars.sy \ + tl-type.sy \ + tl-type-4x.sy \ + twolets2-orig.sy \ + unbdd_inv_gen_winf1.sy \ + array_search_2.sy \ + array_sum_2_5.sy \ + commutative.sy \ + constant.sy \ + dt-test-ns.sy \ + hd-19-d1-prog-dup-op.sy \ + list-head-x.sy \ + max.sy \ + nflat-fwd-3.sy \ + nflat-fwd.sy \ + nia-max-square-ns.sy \ + no-mention.sy \ + qe.sy \ + strings-concat-3-args.sy \ + strings-double-rec.sy \ + strings-small.sy \ + strings-template-infer-unused.sy \ + strings-template-infer.sy \ + strings-trivial-simp.sy \ + strings-trivial-two-type.sy \ + strings-trivial.sy \ + sygus-dt.sy \ + tl-type-0.sy \ + triv-type-mismatch-si.sy \ + twolets1.sy -EXTRA_DIST = $(TESTS) +EXTRA_DIST = $(TESTS) \ + enum-test.sy + +# Base16_1.sy # synonyms for "check" in this directory .PHONY: regress regress1 test diff --git a/test/regress/regress1/sygus/array_search_2.sy b/test/regress/regress1/sygus/array_search_2.sy new file mode 100644 index 000000000..41346e655 --- /dev/null +++ b/test/regress/regress1/sygus/array_search_2.sy @@ -0,0 +1,11 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic LIA) +(synth-fun findIdx ( (y1 Int) (y2 Int) (k1 Int)) Int ((Start Int ( 0 1 2 y1 y2 k1 (ite BoolExpr Start Start))) (BoolExpr Bool ((< Start Start) (<= Start Start) (> Start Start) (>= Start Start))))) +(declare-var x1 Int) +(declare-var x2 Int) +(declare-var k Int) +(constraint (=> (< x1 x2) (=> (< k x1) (= (findIdx x1 x2 k) 0)))) +(constraint (=> (< x1 x2) (=> (> k x2) (= (findIdx x1 x2 k) 2)))) +(constraint (=> (< x1 x2) (=> (and (> k x1) (< k x2)) (= (findIdx x1 x2 k) 1)))) +(check-synth) diff --git a/test/regress/regress1/sygus/array_sum_2_5.sy b/test/regress/regress1/sygus/array_sum_2_5.sy new file mode 100644 index 000000000..84a75d086 --- /dev/null +++ b/test/regress/regress1/sygus/array_sum_2_5.sy @@ -0,0 +1,9 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic LIA) +(synth-fun findSum ( (y1 Int) (y2 Int) )Int ((Start Int ( 0 1 2 y1 y2 (+ Start Start) (ite BoolExpr Start Start))) (BoolExpr Bool ((< Start Start) (<= Start Start) (> Start Start) (>= Start Start))))) +(declare-var x1 Int) +(declare-var x2 Int) +(constraint (=> (> (+ x1 x2) 5) (= (findSum x1 x2 ) (+ x1 x2)))) +(constraint (=> (<= (+ x1 x2) 5) (= (findSum x1 x2 ) 0))) +(check-synth) diff --git a/test/regress/regress1/sygus/array_sum_dd.sy b/test/regress/regress1/sygus/array_sum_dd.sy deleted file mode 100644 index 6d3354d2d..000000000 --- a/test/regress/regress1/sygus/array_sum_dd.sy +++ /dev/null @@ -1,11 +0,0 @@ -; EXPECT: unsat -; COMMAND-LINE: --sygus-out=status -(set-logic LIA) -(synth-fun findSum ( (y1 Int) (y2 Int) )Int ( -(Start Int ( 0 1 y1 y2 (+ Start Start) (ite BoolExpr Start Start))) -(BoolExpr Bool ((< Start Start) (<= Start Start))))) -(declare-var x1 Int) -(declare-var x2 Int) -(constraint (=> (> (+ x1 x2) 0) (= (findSum x1 x2 ) x1))) -(constraint (=> (<= (+ x1 x2) 0) (= (findSum x1 x2 ) x2))) -(check-synth) diff --git a/test/regress/regress1/sygus/cegar1.sy b/test/regress/regress1/sygus/cegar1.sy new file mode 100644 index 000000000..ee85db88a --- /dev/null +++ b/test/regress/regress1/sygus/cegar1.sy @@ -0,0 +1,23 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-inv-templ=post --sygus-out=status +(set-logic LIA) + +(synth-inv inv-f ((x Int) (y Int))) + +(declare-primed-var x Int) +(declare-primed-var y Int) + +(define-fun pre-f ((x Int) (y Int)) Bool +(and (and (>= x 0) +(and (<= x 2) +(<= y 2))) (>= y 0))) + +(define-fun trans-f ((x Int) (y Int) (x! Int) (y! Int)) Bool +(and (= x! (+ x 2)) (= y! (+ y 2)))) + +(define-fun post-f ((x Int) (y Int)) Bool +(not (and (= x 4) (= y 0)))) + +(inv-constraint inv-f pre-f trans-f post-f) + +(check-synth) diff --git a/test/regress/regress1/sygus/cggmp.sy b/test/regress/regress1/sygus/cggmp.sy new file mode 100644 index 000000000..a3247e4f4 --- /dev/null +++ b/test/regress/regress1/sygus/cggmp.sy @@ -0,0 +1,23 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-inv-templ=pre --sygus-out=status + +(set-logic LIA) + +(synth-inv inv-f ((i Int) (j Int))) + +(declare-primed-var i Int) +(declare-primed-var j Int) + +(define-fun pre-f ((i Int) (j Int)) Bool +(and (= i 1) +(= j 10))) + +(define-fun trans-f ((i Int) (j Int) (i! Int) (j! Int)) Bool +(and (and (>= j i) (= i! (+ i 2))) (= j! (- j 1)))) + +(define-fun post-f ((i Int) (j Int)) Bool +(not (and (< j i) (not (= j 6))))) + +(inv-constraint inv-f pre-f trans-f post-f) + +(check-synth) diff --git a/test/regress/regress1/sygus/clock-inc-tuple.sy b/test/regress/regress1/sygus/clock-inc-tuple.sy new file mode 100644 index 000000000..43fd7c1ac --- /dev/null +++ b/test/regress/regress1/sygus/clock-inc-tuple.sy @@ -0,0 +1,14 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status + +(set-logic ALL_SUPPORTED) +(declare-var m Int) +(declare-var s Int) +(declare-var inc Int) +(declare-datatypes ((tuple2 0)) ( ((tuple2 (_m Int) (_s Int))) )) + +(synth-fun x12 ((m Int) (s Int) (inc Int)) tuple2) +(constraint (=> +(and (>= m 0) (>= s 0) (< s 3) (> inc 0)) +(and (>= (_m (x12 m s inc)) 0) (>= (_s (x12 m s inc)) 0) (< (_s (x12 m s inc)) 3) (= (+ (* (_m (x12 m s inc)) 3) (_s (x12 m s inc))) (+ (+ (* m 3) s) inc))))) +(check-synth) diff --git a/test/regress/regress1/sygus/commutative.sy b/test/regress/regress1/sygus/commutative.sy new file mode 100644 index 000000000..24201b453 --- /dev/null +++ b/test/regress/regress1/sygus/commutative.sy @@ -0,0 +1,22 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status + +(set-logic LIA) + +(synth-fun comm ((x Int) (y Int)) Int + ((Start Int (x + y + (+ Start Start) + (- Start Start) + )) + )) + +(declare-var x Int) +(declare-var y Int) + +(constraint (= (comm x y) (comm y x))) + + +(check-synth) + +; (+ x y) is a valid solution diff --git a/test/regress/regress1/sygus/constant.sy b/test/regress/regress1/sygus/constant.sy new file mode 100644 index 000000000..1bb3e59fa --- /dev/null +++ b/test/regress/regress1/sygus/constant.sy @@ -0,0 +1,23 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status + +(set-logic LIA) + +(synth-fun constant ((x Int)) Int + ((Start Int (x + 0 + 1 + (+ Start Start) + (- Start Start) + )) + )) + +(declare-var x Int) +(declare-var y Int) + +(constraint (= (constant x) (constant y))) + + +(check-synth) + +; 0, 1, (- x x) are valid solutions diff --git a/test/regress/regress1/sygus/dt-test-ns.sy b/test/regress/regress1/sygus/dt-test-ns.sy new file mode 100644 index 000000000..a6e8ac5c2 --- /dev/null +++ b/test/regress/regress1/sygus/dt-test-ns.sy @@ -0,0 +1,14 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic LIA) + +(declare-datatypes ((List 0)) (((cons (head Int) (tail List)) (nil)))) + +(synth-fun f ((x Int)) List) + +(declare-var x Int) + +(constraint (is-cons (f x))) +(constraint (and (= (head (f x)) x) (= (head (f x)) (+ 5 (head (tail (f x))))))) +(check-synth) + diff --git a/test/regress/regress1/sygus/dup-op.sy b/test/regress/regress1/sygus/dup-op.sy new file mode 100644 index 000000000..e2c69282e --- /dev/null +++ b/test/regress/regress1/sygus/dup-op.sy @@ -0,0 +1,11 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=none --sygus-out=status +(set-logic LIA) +(synth-fun f ((x Int)) Int + ((Start Int ((+ Con Con) (+ Start Start) x)) + (Con Int (0 1)))) + +(declare-var x Int) +(constraint (= (f x) (* 2 x))) +(check-synth) + diff --git a/test/regress/regress1/sygus/enum-test.sy b/test/regress/regress1/sygus/enum-test.sy new file mode 100644 index 000000000..47099eeed --- /dev/null +++ b/test/regress/regress1/sygus/enum-test.sy @@ -0,0 +1,8 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic LIA) +(define-sort D (Enum (a b))) +(define-fun f ((x D)) Int (ite (= x D::a) 3 7)) +(synth-fun g () D ((Start D (D::a D::b)))) +(constraint (= (f g) 7)) +(check-synth) diff --git a/test/regress/regress1/sygus/fg_polynomial3.sy b/test/regress/regress1/sygus/fg_polynomial3.sy new file mode 100644 index 000000000..d70516bf1 --- /dev/null +++ b/test/regress/regress1/sygus/fg_polynomial3.sy @@ -0,0 +1,18 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status + +(set-logic LIA) + +(synth-fun addExpr1 ((x Int) (y Int)) Int +) + +(synth-fun addExpr2 ((x Int) (y Int)) Int +) + +(declare-var x Int) +(declare-var y Int) + +(constraint (= (+ (addExpr1 x y) (addExpr2 y x)) (- x (+ x y)))) + +(check-synth) + diff --git a/test/regress/regress1/sygus/hd-01-d1-prog.sy b/test/regress/regress1/sygus/hd-01-d1-prog.sy new file mode 100644 index 000000000..1379d4206 --- /dev/null +++ b/test/regress/regress1/sygus/hd-01-d1-prog.sy @@ -0,0 +1,22 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi --sygus-out=status + +(set-logic BV) + +(define-fun hd01 ((x (BitVec 32))) (BitVec 32) (bvand x (bvsub x #x00000001))) + +(synth-fun f ((x (BitVec 32))) (BitVec 32) + ((Start (BitVec 32) ((bvand Start Start) + (bvsub Start Start) + (bvor Start Start) + (bvadd Start Start) + (bvxor Start Start) + x + #x00000000 + #xFFFFFFFF + #x00000001)))) + +(declare-var x (BitVec 32)) +(constraint (= (hd01 x) (f x))) +(check-synth) + diff --git a/test/regress/regress1/sygus/hd-19-d1-prog-dup-op.sy b/test/regress/regress1/sygus/hd-19-d1-prog-dup-op.sy new file mode 100644 index 000000000..abcfc2217 --- /dev/null +++ b/test/regress/regress1/sygus/hd-19-d1-prog-dup-op.sy @@ -0,0 +1,32 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status + +(set-logic BV) + +(define-fun hd19 ((x (BitVec 32)) (m (BitVec 32)) (k (BitVec 32))) (BitVec 32) + (bvxor x (bvxor (bvshl (bvand (bvxor (bvlshr x k) x) m) k) (bvand (bvxor (bvlshr x k) x) m)))) + +; bvand is a duplicate +(synth-fun f ((x (BitVec 32)) (m (BitVec 32)) (k (BitVec 32))) (BitVec 32) + ((Start (BitVec 32) ((bvand Start Start) + (bvsub Start Start) + (bvxor Start Start) + (bvor Start Start) + (bvand Start Start) + (bvshl Start Start) + (bvlshr Start Start) + (bvashr Start Start) + (bvnot Start) + (bvneg Start) + x + m + k)))) + + +(declare-var x (BitVec 32)) +(declare-var m (BitVec 32)) +(declare-var k (BitVec 32)) + +(constraint (= (hd19 x m k) (f x m k))) +(check-synth) + diff --git a/test/regress/regress1/sygus/icfp_14.12-flip-args.sy b/test/regress/regress1/sygus/icfp_14.12-flip-args.sy new file mode 100644 index 000000000..a1e93cc44 --- /dev/null +++ b/test/regress/regress1/sygus/icfp_14.12-flip-args.sy @@ -0,0 +1,55 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic BV) + +(define-fun shr1 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000001)) +(define-fun shr4 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000004)) +(define-fun shr16 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000010)) +(define-fun shl1 ((x (BitVec 64))) (BitVec 64) (bvshl x #x0000000000000001)) +(define-fun if0 ((y (BitVec 64)) (x (BitVec 64)) (z (BitVec 64))) (BitVec 64) (ite (= x #x0000000000000001) y z)) + +(synth-fun f ( (x (BitVec 64))) (BitVec 64) +( + +(Start (BitVec 64) (#x0000000000000000 #x0000000000000001 x (bvnot Start) + (shl1 Start) + (shr1 Start) + (shr4 Start) + (shr16 Start) + (bvand Start Start) + (bvor Start Start) + (bvxor Start Start) + (bvadd Start Start) + (if0 Start Start Start) + )) +) +) +(constraint (= (f #x6E393354DFFAAB51) #xC8E366559002AA57)) +(constraint (= (f #xFDA75AD598A27135) #x812C529533AEC765)) +(constraint (= (f #x58682C0FA4F8DB6D) #xD3CBE9F82D839249)) +(constraint (= (f #x58FDC0941A7E079F) #xD3811FB5F2C0FC30)) +(constraint (= (f #xBDC9B88103ECB0C9) #xA11B23BF7E09A79B)) +(constraint (= (f #x000000000001502F) #xFFFFFFFFFFFF57E8)) +(constraint (= (f #x0000000000010999) #xFFFFFFFFFFFF7B33)) +(constraint (= (f #x0000000000013169) #xFFFFFFFFFFFF674B)) +(constraint (= (f #x000000000001B1A9) #xFFFFFFFFFFFF272B)) +(constraint (= (f #x0000000000016D77) #xFFFFFFFFFFFF4944)) +(constraint (= (f #x0000000000000001) #xFFFFFFFFFFFFFFFF)) +(constraint (= (f #x1ED2E25068744C80) #x0000000000000000)) +(constraint (= (f #x2D2144F9D8CDCBD6) #x0000000000000000)) +(constraint (= (f #xF0F0F0F0F0F0F0F2) #x0000000000000000)) +(constraint (= (f #x83163CFD5DDCCCFB) #xBE74E18151119982)) +(constraint (= (f #xEA31B6A50EF4E399) #x8AE724AD78858E33)) +(constraint (= (f #xE0B1EF549BB6D4B9) #x8FA70855B22495A3)) +(constraint (= (f #x086F9E13A16C363D) #xFBC830F62F49E4E1)) +(constraint (= (f #x2426824D3E67E342) #x0000000000000000)) +(constraint (= (f #xDD518DEFFF18308A) #x0000000000000000)) +(constraint (= (f #x21ECDADB06B3CB03) #xEF0992927CA61A7E)) +(constraint (= (f #x72B1976FBB63A82B) #xC6A73448224E2BEA)) +(constraint (= (f #x16CB47AE0281B27F) #xF49A5C28FEBF26C0)) +(constraint (= (f #x82DE7A1FCA0C0B8F) #xBE90C2F01AF9FA38)) +(constraint (= (f #x0000000000000001) #xFFFFFFFFFFFFFFFF)) +(constraint (= (f #xF0F0F0F0F0F0F0F2) #x0000000000000000)) +(constraint (= (f #x000000000001F0D4) #x0000000000000000)) +(constraint (= (f #x0000000000010067) #xFFFFFFFFFFFF7FCC)) +(check-synth) diff --git a/test/regress/regress1/sygus/icfp_14.12.sy b/test/regress/regress1/sygus/icfp_14.12.sy new file mode 100644 index 000000000..51b86f0f5 --- /dev/null +++ b/test/regress/regress1/sygus/icfp_14.12.sy @@ -0,0 +1,63 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic BV) + +(define-fun shr1 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000001)) +(define-fun shr4 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000004)) +(define-fun shr16 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000010)) +(define-fun shl1 ((x (BitVec 64))) (BitVec 64) (bvshl x #x0000000000000001)) +(define-fun if0 ((x (BitVec 64)) (y (BitVec 64)) (z (BitVec 64))) (BitVec 64) (ite (= x #x0000000000000001) y z)) + +(synth-fun f ( (x (BitVec 64))) (BitVec 64) +( + +(Start (BitVec 64) (#x0000000000000000 #x0000000000000001 x (bvnot Start) + (shl1 Start) + (shr1 Start) + (shr4 Start) + (shr16 Start) + (bvand Start Start) + (bvor Start Start) + (bvxor Start Start) + (bvadd Start Start) + (if0 Start Start Start) + )) +) +) +(constraint (= (f #x6E393354DFFAAB51) #xC8E366559002AA57)) +(constraint (= (f #xFDA75AD598A27135) #x812C529533AEC765)) +(constraint (= (f #x58682C0FA4F8DB6D) #xD3CBE9F82D839249)) +(constraint (= (f #x58FDC0941A7E079F) #xD3811FB5F2C0FC30)) +(constraint (= (f #xBDC9B88103ECB0C9) #xA11B23BF7E09A79B)) +(constraint (= (f #x000000000001502F) #xFFFFFFFFFFFF57E8)) +(constraint (= (f #x0000000000010999) #xFFFFFFFFFFFF7B33)) +(constraint (= (f #x0000000000013169) #xFFFFFFFFFFFF674B)) +(constraint (= (f #x000000000001B1A9) #xFFFFFFFFFFFF272B)) +(constraint (= (f #x0000000000016D77) #xFFFFFFFFFFFF4944)) +(constraint (= (f #x0000000000000001) #xFFFFFFFFFFFFFFFF)) +(constraint (= (f #x1ED2E25068744C80) #x0000000000000000)) +(constraint (= (f #x2D2144F9D8CDCBD6) #x0000000000000000)) +(constraint (= (f #xE5D371D100002E8A) #x0000000000000000)) +(constraint (= (f #xADFF6BA34EBDAD72) #x0000000000000000)) +(constraint (= (f #xDA9299B546AAB59A) #x0000000000000000)) +(constraint (= (f #x0000000000015C8A) #x0000000000000000)) +(constraint (= (f #x0000000000017066) #x0000000000000000)) +(constraint (= (f #x000000000001D9D8) #x0000000000000000)) +(constraint (= (f #x00000000000151AE) #x0000000000000000)) +(constraint (= (f #x0000000000017A14) #x0000000000000000)) +(constraint (= (f #xF0F0F0F0F0F0F0F2) #x0000000000000000)) +(constraint (= (f #x83163CFD5DDCCCFB) #xBE74E18151119982)) +(constraint (= (f #xEA31B6A50EF4E399) #x8AE724AD78858E33)) +(constraint (= (f #xE0B1EF549BB6D4B9) #x8FA70855B22495A3)) +(constraint (= (f #x086F9E13A16C363D) #xFBC830F62F49E4E1)) +(constraint (= (f #x2426824D3E67E342) #x0000000000000000)) +(constraint (= (f #xDD518DEFFF18308A) #x0000000000000000)) +(constraint (= (f #x21ECDADB06B3CB03) #xEF0992927CA61A7E)) +(constraint (= (f #x72B1976FBB63A82B) #xC6A73448224E2BEA)) +(constraint (= (f #x16CB47AE0281B27F) #xF49A5C28FEBF26C0)) +(constraint (= (f #x82DE7A1FCA0C0B8F) #xBE90C2F01AF9FA38)) +(constraint (= (f #x0000000000000001) #xFFFFFFFFFFFFFFFF)) +(constraint (= (f #xF0F0F0F0F0F0F0F2) #x0000000000000000)) +(constraint (= (f #x000000000001F0D4) #x0000000000000000)) +(constraint (= (f #x0000000000010067) #xFFFFFFFFFFFF7FCC)) +(check-synth) diff --git a/test/regress/regress1/sygus/icfp_28_10.sy b/test/regress/regress1/sygus/icfp_28_10.sy new file mode 100644 index 000000000..212ae37f5 --- /dev/null +++ b/test/regress/regress1/sygus/icfp_28_10.sy @@ -0,0 +1,40 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status + +(set-logic BV) + +(define-fun shr1 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000001)) +(define-fun shr4 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000004)) +(define-fun shr16 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000010)) +(define-fun shl1 ((x (BitVec 64))) (BitVec 64) (bvshl x #x0000000000000001)) +(define-fun if0 ((x (BitVec 64)) (y (BitVec 64)) (z (BitVec 64))) (BitVec 64) (ite (= x #x0000000000000001) y z)) + +(synth-fun f ( (x (BitVec 64))) (BitVec 64) +( + +(Start (BitVec 64) (#x0000000000000000 #x0000000000000001 x (bvnot Start) + (shl1 Start) + (shr1 Start) + (shr4 Start) + (shr16 Start) + (bvand Start Start) + (bvor Start Start) + (bvxor Start Start) + (bvadd Start Start) + (if0 Start Start Start) + )) +) +) + + +(constraint (= (f #xd74594057974e439) #x0000d74594057974)) +(constraint (= (f #x74641ebeee92e8a2) #x000074641ebeee92)) +(constraint (= (f #x91c80141d7ec76b1) #x000091c80141d7ec)) +(constraint (= (f #xe4e55862e5ee4bec) #x0000e4e55862e5ee)) +(constraint (= (f #x367da67ede4260ce) #x0000367da67ede42)) +(constraint (= (f #xa365eb36246b3d8e) #x0000a365eb36246b)) +(constraint (= (f #xcd8a44a6d4c09c29) #x0000cd8a44a6d4c0)) +(constraint (= (f #xa97e9b9b7970433d) #x0000a97e9b9b7970)) +(constraint (= (f #x474dec0dd75d6894) #x0000474dec0dd75d)) +(constraint (= (f #x12430014ed058b24) #x000012430014ed05)) +(check-synth) diff --git a/test/regress/regress1/sygus/icfp_easy_mt_ite.sy b/test/regress/regress1/sygus/icfp_easy-ite.sy index 799633fa3..f0cbbdc53 100644 --- a/test/regress/regress1/sygus/icfp_easy_mt_ite.sy +++ b/test/regress/regress1/sygus/icfp_easy-ite.sy @@ -25,7 +25,9 @@ (StartBool Bool ((= Start #x0000000000000001))) ) ) -(constraint (= (f #x6E393354DFFAAB51) #xC8E366559002AA57)) +(constraint (= (f #x0000000000000001) #x0000000000000001)) + +(constraint (= (f #x0000000000100001) #x0000000000100001)) (constraint (= (f #xE5D371D100002E8A) #x0000000000000000)) diff --git a/test/regress/regress1/sygus/inv-example.sy b/test/regress/regress1/sygus/inv-example.sy new file mode 100644 index 000000000..ff68bc06c --- /dev/null +++ b/test/regress/regress1/sygus/inv-example.sy @@ -0,0 +1,12 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic LIA) +(synth-inv inv-f ((x Int) (y Int) (b Bool))) +(declare-primed-var x Int) +(declare-primed-var y Int) +(declare-primed-var b Bool) +(define-fun pre-f ((x Int) (y Int) (b Bool)) Bool (and (and (>= x 5) (<= x 9)) (and (>= y 1) (<= y 3)))) +(define-fun trans-f ((x Int) (y Int) (b Bool) (x! Int) (y! Int) (b! Bool)) Bool (and (and (= b! b) (= y! x)) (ite b (= x! (+ x 10)) (= x! (+ x 12))))) +(define-fun post-f ((x Int) (y Int) (b Bool)) Bool (<= y x)) +(inv-constraint inv-f pre-f trans-f post-f) +(check-synth) diff --git a/test/regress/regress1/sygus/inv-unused.sy b/test/regress/regress1/sygus/inv-unused.sy new file mode 100644 index 000000000..91ba95d39 --- /dev/null +++ b/test/regress/regress1/sygus/inv-unused.sy @@ -0,0 +1,13 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic LIA) +(synth-inv inv-f ((x Int) (y Int) (b Bool))) +(declare-primed-var x Int) +(declare-primed-var y Int) +(declare-primed-var b Bool) +(define-fun pre-f ((x Int) (y Int) (b Bool)) Bool (and (>= x 5) (<= x 9))) +(define-fun trans-f ((x Int) (y Int) (b Bool) (x! Int) (y! Int) (b! Bool)) Bool (= x! (+ x 1))) +(define-fun post-f ((x Int) (y Int) (b Bool)) Bool (> x 0)) +(inv-constraint inv-f pre-f trans-f post-f) +; invariant does not depend on arguments y and b +(check-synth) diff --git a/test/regress/regress1/sygus/list-head-x.sy b/test/regress/regress1/sygus/list-head-x.sy new file mode 100644 index 000000000..6c5c1a97b --- /dev/null +++ b/test/regress/regress1/sygus/list-head-x.sy @@ -0,0 +1,13 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic ALL_SUPPORTED) + +(declare-datatypes ((List 0)) (((cons (head Int) (tail List)) (nil)))) + +(synth-fun f ((x Int)) List) + +(declare-var x Int) + +(constraint (is-cons (f x))) +(constraint (= (head (f x)) (+ x 7))) +(check-synth) diff --git a/test/regress/regress1/sygus/lustre-real.sy b/test/regress/regress1/sygus/lustre-real.sy deleted file mode 100644 index 2ca010898..000000000 --- a/test/regress/regress1/sygus/lustre-real.sy +++ /dev/null @@ -1,322 +0,0 @@ -; EXPECT: unsat -; COMMAND-LINE: --cegqi-si=none --sygus-out=status -(set-logic LIRA) -(define-fun -__node_init_top_0 ( -(top.usr.onOff@0 Bool) (top.usr.decelSet@0 Bool) (top.usr.accelResume@0 Bool) (top.usr.cancel@0 Bool) (top.usr.brakePedal@0 Bool) (top.usr.carGear@0 Int) (top.usr.carSpeed@0 Real) (top.usr.validInputs@0 Bool) (top.usr.OK@0 Bool) (top.res.init_flag@0 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@0 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@0 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root@0 Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 Int) ) Bool - -(let ((X1 Int 0)) (let ((X2 Int (ite (not (= X1 1)) 1 X1))) (let ((X3 Bool (or (= X2 1) (and (>= X2 2) (<= X2 8))))) (and (= top.usr.OK@0 X3) (let ((X4 Bool false)) (let ((X5 Bool (and (and (and (and (not top.usr.cancel@0) (not top.usr.brakePedal@0)) (ite (= top.usr.carGear@0 3) true false)) (ite (>= top.usr.carSpeed@0 15.0) true false)) top.usr.validInputs@0))) (let ((X6 Bool false)) (and (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 -(ite (<= (ite (>= 0 (ite top.usr.decelSet@0 1 0)) 0 -(ite top.usr.decelSet@0 1 0)) 20) (ite (>= 0 (ite top.usr.decelSet@0 1 0)) 0 -(ite top.usr.decelSet@0 1 0)) 20)) (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 -(ite (<= (ite (>= 0 (ite top.usr.accelResume@0 1 0)) 0 -(ite top.usr.accelResume@0 1 0)) 20) (ite (>= 0 (ite top.usr.accelResume@0 1 0)) 0 -(ite top.usr.accelResume@0 1 0)) 20)) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@0 true) (let ((X7 Int (ite (not top.usr.onOff@0) 0 1))) (let ((X8 Bool (and (and (>= X1 2) (<= X1 8)) (not (ite (not (= X7 0)) true false))))) (let ((X9 Int (ite X8 (ite (and (>= X1 2) (<= X1 8)) 0 X1) X1))) (let ((X10 Int (ite X8 (ite (not (= X9 1)) 1 X9) X9))) (let ((X11 Bool (and (= X10 1) (and (ite (not (= X7 0)) true false) (not X8))))) (let ((X12 Int (ite X11 (ite (= X10 1) 0 X10) X10))) (let ((X13 Int (ite (not (and (>= X12 2) (<= X12 8))) 2 X12))) (let ((X14 Bool (and (not (and (>= X12 2) (<= X12 8))) (and (>= X13 2) (<= X13 8))))) (let ((X15 Int (ite X14 (ite (not (= X13 7)) 7 X13) X13))) (let ((X16 Int (ite X11 X15 X12))) (let ((X17 Bool (or X11 X8))) (let ((X18 Int (ite (not X5) 0 1))) (let ((X19 Bool (and (and (>= X16 3) (<= X16 6)) (not (ite (not (= X18 0)) true false))))) (let ((X20 -Int (ite X19 -(ite (and (>= X16 3) (<= X16 6)) 2 X16) X16))) (let ((X21 Int (ite X19 (ite (not (= X20 8)) 8 X20) X20))) (let ((X22 Int (ite (not X4) 0 1))) (let ((X23 Bool (and (= X21 8) (and (and (ite (not (= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not (= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X19))))) (let ((X24 Int (ite X23 (ite (= X21 8) 2 X21) X21))) (let ((X25 -Int (ite (not (and (>= X24 3) (<= X24 6))) 3 X24))) (let ((X26 Bool (and (not (and (>= X24 3) (<= X24 6))) (and (>= X25 3) (<= X25 6))))) (let ((X27 -Int (ite X26 -(ite (not (= X25 4)) 4 X25) X25))) (let ((X28 Int (ite X23 X27 X24))) (let ((X29 Bool (or X23 X19))) (let ((X30 Bool (and (= X28 8) (and (and (ite (not -(= (ite (not -(= (ite (not X6) 0 1) 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X29))))) (let ((X31 -Int (ite X30 (ite (= X28 8) 2 X28) X28))) (let ((X32 -Int (ite (not (and (>= X31 3) (<= X31 6))) 3 X31))) (let ((X33 Bool (and (not -(and (>= X31 3) (<= X31 6))) (and (>= X32 3) (<= X32 6))))) (let ((X34 -Int (ite X33 -(ite (not (= X32 4)) 4 X32) X32))) (let ((X35 Int (ite X30 X34 X31))) (let ((X36 Bool (or X30 X29))) (let ((X37 Bool (and (= X35 7) (and (and (ite (not -(= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X36))))) (let ((X38 -Int (ite X37 -(ite (= X35 7) 2 X35) X35))) (let ((X39 -Int (ite (not -(and (>= X38 3) (<= X38 6))) 3 X38))) (let ((X40 Bool (and (not -(and (>= X38 3) (<= X38 6))) (and (>= X39 3) (<= X39 6))))) (let ((X41 -Int (ite X40 -(ite (not (= X39 4)) 4 X39) X39))) (let ((X42 Int (ite X37 X41 X38))) (let ((X43 Bool (or X37 X36))) (let ((X44 Bool (and (= X42 4) (= X22 1)))) (let ((X45 -Int (ite X44 -(ite (= X42 4) 3 X42) X42))) (let ((X46 -Int (ite X44 -(ite (not (= X45 4)) 4 X45) X45))) (let ((X47 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 20) true false)) 0 1))) (let ((X48 Bool (and (= X46 4) (and (= X47 1) (not X44))))) (let ((X49 -Int (ite X48 -(ite (= X46 4) 3 X46) X46))) (let ((X50 -Int (ite X48 -(ite (not (= X49 5)) 5 X49) X49))) (let ((X51 Bool (or X48 X44))) (let ((X52 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 20) true false)) 0 1))) (let ((X53 Bool (and (= X50 4) (and (= X52 1) (not X51))))) (let ((X54 -Int (ite X53 -(ite (= X50 4) 3 X50) X50))) (let ((X55 -Int (ite X53 -(ite (not -(= X54 6)) 6 X54) X54))) (let ((X56 Bool (or X53 X51))) (let ((X57 Bool (and (= X55 6) (and (= X52 0) (not X56))))) (let ((X58 -Int (ite X57 -(ite (= X55 6) 3 X55) X55))) (let ((X59 -Int (ite X57 -(ite (not -(= X58 4)) 4 X58) X58))) (let ((X60 Bool -(or X57 X56))) (let ((X61 Bool -(and (= X59 5) (and (= X47 0) (not X60))))) (let ((X62 -Int (ite X61 -(ite (= X59 5) 3 X59) X59))) (let ((X63 -Int (ite X61 -(ite (not -(= X62 4)) 4 X62) X62))) (and (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@0 true) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root@0 -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@0 -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@0 X2 -(ite (and (not X17) (and (>= X16 2) (<= X16 -8))) (ite (and (not X43) (and (>= X42 -3) (<= X42 -6))) X63 X42) X16)) X1)) (<= 0 X47 1) (<= 0 X22 1) (<= 0 X18 1) (<= 0 X7 1) (<= 0 X52 1) top.res.init_flag@0)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ) -(define-fun -__node_trans_top_0 ( -(top.usr.onOff@1 Bool) (top.usr.decelSet@1 Bool) (top.usr.accelResume@1 Bool) (top.usr.cancel@1 Bool) (top.usr.brakePedal@1 Bool) (top.usr.carGear@1 Int) (top.usr.carSpeed@1 Real) (top.usr.validInputs@1 Bool) (top.usr.OK@1 Bool) (top.res.init_flag@1 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@1 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@1 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root@1 Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@1 Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@1 Int) (top.usr.onOff@0 Bool) (top.usr.decelSet@0 Bool) (top.usr.accelResume@0 Bool) (top.usr.cancel@0 Bool) (top.usr.brakePedal@0 Bool) (top.usr.carGear@0 Int) (top.usr.carSpeed@0 Real) (top.usr.validInputs@0 Bool) (top.usr.OK@0 Bool) (top.res.init_flag@0 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@0 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@0 Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root@0 Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 Int) ) Bool - -(let ((X1 -Int top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root@0)) (let ((X2 Int (ite (not (= X1 1)) 1 X1))) (let ((X3 Bool (or (= X2 1) (and (>= X2 2) (<= X2 8))))) (and (= top.usr.OK@1 X3) (let ((X4 Bool (and (not top.usr.decelSet@0) top.usr.decelSet@1))) (let ((X5 Bool (and (and (and (and (not top.usr.cancel@1) (not top.usr.brakePedal@1)) (ite (= top.usr.carGear@1 3) true false)) (ite (>= top.usr.carSpeed@1 15.0) true false)) top.usr.validInputs@1))) (let ((X6 Bool (and (not top.usr.accelResume@0) top.usr.accelResume@1))) (and (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@1 -(ite (<= (ite (>= 0 -(ite top.usr.decelSet@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 1) 0)) 0 -(ite top.usr.decelSet@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 1) 0)) 20) (ite (>= 0 -(ite top.usr.decelSet@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 1) 0)) 0 -(ite top.usr.decelSet@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@0 1) 0)) 20)) (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@1 -(ite (<= (ite (>= 0 -(ite top.usr.accelResume@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 1) 0)) 0 -(ite top.usr.accelResume@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 1) 0)) 20) (ite (>= 0 -(ite top.usr.accelResume@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 1) 0)) 0 -(ite top.usr.accelResume@1 -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@0 1) 0)) 20)) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@1 -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@0 -false top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@0)) (let ((X7 Int (ite (not top.usr.onOff@1) 0 1))) (let ((X8 Bool (and (and (>= X1 2) (<= X1 8)) (not (ite (not (= X7 0)) true false))))) (let ((X9 Int (ite X8 (ite (and (>= X1 2) (<= X1 8)) 0 X1) X1))) (let ((X10 Int (ite X8 (ite (not (= X9 1)) 1 X9) X9))) (let ((X11 Bool (and (= X10 1) (and (ite (not (= X7 0)) true false) (not X8))))) (let ((X12 Int (ite X11 (ite (= X10 1) 0 X10) X10))) (let ((X13 Int (ite (not (and (>= X12 2) (<= X12 8))) 2 X12))) (let ((X14 Bool (and (not (and (>= X12 2) (<= X12 8))) (and (>= X13 2) (<= X13 8))))) (let ((X15 Int (ite X14 (ite (not (= X13 7)) 7 X13) X13))) (let ((X16 Int (ite X11 X15 X12))) (let ((X17 Bool (or X11 X8))) (let ((X18 Int (ite (not X5) 0 1))) (let ((X19 Bool (and (and (>= X16 3) (<= X16 6)) (not (ite (not (= X18 0)) true false))))) (let ((X20 -Int (ite X19 -(ite (and (>= X16 3) (<= X16 6)) 2 X16) X16))) (let ((X21 Int (ite X19 (ite (not (= X20 8)) 8 X20) X20))) (let ((X22 Int (ite (not X4) 0 1))) (let ((X23 Bool (and (= X21 8) (and (and (ite (not (= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not (= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X19))))) (let ((X24 Int (ite X23 (ite (= X21 8) 2 X21) X21))) (let ((X25 -Int (ite (not (and (>= X24 3) (<= X24 6))) 3 X24))) (let ((X26 Bool (and (not (and (>= X24 3) (<= X24 6))) (and (>= X25 3) (<= X25 6))))) (let ((X27 -Int (ite X26 -(ite (not (= X25 4)) 4 X25) X25))) (let ((X28 Int (ite X23 X27 X24))) (let ((X29 Bool (or X23 X19))) (let ((X30 Bool (and (= X28 8) (and (and (ite (not -(= (ite (not -(= (ite (not X6) 0 1) 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X29))))) (let ((X31 -Int (ite X30 (ite (= X28 8) 2 X28) X28))) (let ((X32 -Int (ite (not (and (>= X31 3) (<= X31 6))) 3 X31))) (let ((X33 Bool (and (not -(and (>= X31 3) (<= X31 6))) (and (>= X32 3) (<= X32 6))))) (let ((X34 -Int (ite X33 -(ite (not (= X32 4)) 4 X32) X32))) (let ((X35 Int (ite X30 X34 X31))) (let ((X36 Bool (or X30 X29))) (let ((X37 Bool (and (= X35 7) (and (and (ite (not -(= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X36))))) (let ((X38 -Int (ite X37 -(ite (= X35 7) 2 X35) X35))) (let ((X39 -Int (ite (not -(and (>= X38 3) (<= X38 6))) 3 X38))) (let ((X40 Bool (and (not -(and (>= X38 3) (<= X38 6))) (and (>= X39 3) (<= X39 6))))) (let ((X41 -Int (ite X40 -(ite (not (= X39 4)) 4 X39) X39))) (let ((X42 Int (ite X37 X41 X38))) (let ((X43 Bool (or X37 X36))) (let ((X44 Bool (and (= X42 4) (= X22 1)))) (let ((X45 -Int (ite X44 -(ite (= X42 4) 3 X42) X42))) (let ((X46 -Int (ite X44 -(ite (not (= X45 4)) 4 X45) X45))) (let ((X47 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out@1 20) true false)) 0 1))) (let ((X48 Bool (and (= X46 4) (and (= X47 1) (not X44))))) (let ((X49 -Int (ite X48 -(ite (= X46 4) 3 X46) X46))) (let ((X50 -Int (ite X48 -(ite (not (= X49 5)) 5 X49) X49))) (let ((X51 Bool (or X48 X44))) (let ((X52 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out@1 20) true false)) 0 1))) (let ((X53 Bool (and (= X50 4) (and (= X52 1) (not X51))))) (let ((X54 -Int (ite X53 -(ite (= X50 4) 3 X50) X50))) (let ((X55 -Int (ite X53 -(ite (not -(= X54 6)) 6 X54) X54))) (let ((X56 Bool (or X53 X51))) (let ((X57 Bool (and (= X55 6) (and (= X52 0) (not X56))))) (let ((X58 -Int (ite X57 -(ite (= X55 6) 3 X55) X55))) (let ((X59 -Int (ite X57 -(ite (not -(= X58 4)) 4 X58) X58))) (let ((X60 Bool -(or X57 X56))) (let ((X61 Bool -(and (= X59 5) (and (= X47 0) (not X60))))) (let ((X62 -Int (ite X61 -(ite (= X59 5) 3 X59) X59))) (let ((X63 -Int (ite X61 -(ite (not -(= X62 4)) 4 X62) X62))) (and (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@1 true) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root@1 -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___@1 -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep@1 X2 -(ite (and (not X17) (and (>= X16 2) (<= X16 -8))) (ite (and (not X43) (and (>= X42 -3) (<= X42 -6))) X63 X42) X16)) X1)) (<= 0 X47 1) (<= 0 X22 1) (<= 0 X18 1) (<= 0 X7 1) (<= 0 X52 1) (not top.res.init_flag@1))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ) - - -(synth-inv str_invariant( -(top.usr.onOff Bool) (top.usr.decelSet Bool) (top.usr.accelResume Bool) (top.usr.cancel Bool) (top.usr.brakePedal Bool) (top.usr.carGear Int) (top.usr.carSpeed Real) (top.usr.validInputs Bool) (top.usr.OK Bool) (top.res.init_flag Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out Int) )) - -(declare-primed-var top.usr.onOff Bool) (declare-primed-var top.usr.decelSet Bool) (declare-primed-var top.usr.accelResume Bool) (declare-primed-var top.usr.cancel Bool) (declare-primed-var top.usr.brakePedal Bool) (declare-primed-var top.usr.carGear Int) (declare-primed-var top.usr.carSpeed Real) (declare-primed-var top.usr.validInputs Bool) (declare-primed-var top.usr.OK Bool) (declare-primed-var top.res.init_flag Bool) (declare-primed-var top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ Bool) (declare-primed-var top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep Bool) (declare-primed-var top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root Int) (declare-primed-var top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out Int) (declare-primed-var top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out Int) -(define-fun -init ( -(top.usr.onOff Bool) (top.usr.decelSet Bool) (top.usr.accelResume Bool) (top.usr.cancel Bool) (top.usr.brakePedal Bool) (top.usr.carGear Int) (top.usr.carSpeed Real) (top.usr.validInputs Bool) (top.usr.OK Bool) (top.res.init_flag Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out Int) ) Bool - -(let ((X1 Int 0)) (let ((X2 Int (ite (not (= X1 1)) 1 X1))) (let ((X3 Bool (or (= X2 1) (and (>= X2 2) (<= X2 8))))) (and (= top.usr.OK X3) (let ((X4 Bool false)) (let ((X5 Bool (and (and (and (and (not top.usr.cancel) (not top.usr.brakePedal)) (ite (= top.usr.carGear 3) true false)) (ite (>= top.usr.carSpeed 15.0) true false)) top.usr.validInputs))) (let ((X6 Bool false)) (and (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out -(ite (<= (ite (>= 0 (ite top.usr.decelSet 1 0)) 0 -(ite top.usr.decelSet 1 0)) 20) (ite (>= 0 (ite top.usr.decelSet 1 0)) 0 -(ite top.usr.decelSet 1 0)) 20)) (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out -(ite (<= (ite (>= 0 (ite top.usr.accelResume 1 0)) 0 -(ite top.usr.accelResume 1 0)) 20) (ite (>= 0 (ite top.usr.accelResume 1 0)) 0 -(ite top.usr.accelResume 1 0)) 20)) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep true) (let ((X7 Int (ite (not top.usr.onOff) 0 1))) (let ((X8 Bool (and (and (>= X1 2) (<= X1 8)) (not (ite (not (= X7 0)) true false))))) (let ((X9 Int (ite X8 (ite (and (>= X1 2) (<= X1 8)) 0 X1) X1))) (let ((X10 Int (ite X8 (ite (not (= X9 1)) 1 X9) X9))) (let ((X11 Bool (and (= X10 1) (and (ite (not (= X7 0)) true false) (not X8))))) (let ((X12 Int (ite X11 (ite (= X10 1) 0 X10) X10))) (let ((X13 Int (ite (not (and (>= X12 2) (<= X12 8))) 2 X12))) (let ((X14 Bool (and (not (and (>= X12 2) (<= X12 8))) (and (>= X13 2) (<= X13 8))))) (let ((X15 Int (ite X14 (ite (not (= X13 7)) 7 X13) X13))) (let ((X16 Int (ite X11 X15 X12))) (let ((X17 Bool (or X11 X8))) (let ((X18 Int (ite (not X5) 0 1))) (let ((X19 Bool (and (and (>= X16 3) (<= X16 6)) (not (ite (not (= X18 0)) true false))))) (let ((X20 -Int (ite X19 -(ite (and (>= X16 3) (<= X16 6)) 2 X16) X16))) (let ((X21 Int (ite X19 (ite (not (= X20 8)) 8 X20) X20))) (let ((X22 Int (ite (not X4) 0 1))) (let ((X23 Bool (and (= X21 8) (and (and (ite (not (= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not (= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X19))))) (let ((X24 Int (ite X23 (ite (= X21 8) 2 X21) X21))) (let ((X25 -Int (ite (not (and (>= X24 3) (<= X24 6))) 3 X24))) (let ((X26 Bool (and (not (and (>= X24 3) (<= X24 6))) (and (>= X25 3) (<= X25 6))))) (let ((X27 -Int (ite X26 -(ite (not (= X25 4)) 4 X25) X25))) (let ((X28 Int (ite X23 X27 X24))) (let ((X29 Bool (or X23 X19))) (let ((X30 Bool (and (= X28 8) (and (and (ite (not -(= (ite (not -(= (ite (not X6) 0 1) 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X29))))) (let ((X31 -Int (ite X30 (ite (= X28 8) 2 X28) X28))) (let ((X32 -Int (ite (not (and (>= X31 3) (<= X31 6))) 3 X31))) (let ((X33 Bool (and (not -(and (>= X31 3) (<= X31 6))) (and (>= X32 3) (<= X32 6))))) (let ((X34 -Int (ite X33 -(ite (not (= X32 4)) 4 X32) X32))) (let ((X35 Int (ite X30 X34 X31))) (let ((X36 Bool (or X30 X29))) (let ((X37 Bool (and (= X35 7) (and (and (ite (not -(= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X36))))) (let ((X38 -Int (ite X37 -(ite (= X35 7) 2 X35) X35))) (let ((X39 -Int (ite (not -(and (>= X38 3) (<= X38 6))) 3 X38))) (let ((X40 Bool (and (not -(and (>= X38 3) (<= X38 6))) (and (>= X39 3) (<= X39 6))))) (let ((X41 -Int (ite X40 -(ite (not (= X39 4)) 4 X39) X39))) (let ((X42 Int (ite X37 X41 X38))) (let ((X43 Bool (or X37 X36))) (let ((X44 Bool (and (= X42 4) (= X22 1)))) (let ((X45 -Int (ite X44 -(ite (= X42 4) 3 X42) X42))) (let ((X46 -Int (ite X44 -(ite (not (= X45 4)) 4 X45) X45))) (let ((X47 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out 20) true false)) 0 1))) (let ((X48 Bool (and (= X46 4) (and (= X47 1) (not X44))))) (let ((X49 -Int (ite X48 -(ite (= X46 4) 3 X46) X46))) (let ((X50 -Int (ite X48 -(ite (not (= X49 5)) 5 X49) X49))) (let ((X51 Bool (or X48 X44))) (let ((X52 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out 20) true false)) 0 1))) (let ((X53 Bool (and (= X50 4) (and (= X52 1) (not X51))))) (let ((X54 -Int (ite X53 -(ite (= X50 4) 3 X50) X50))) (let ((X55 -Int (ite X53 -(ite (not -(= X54 6)) 6 X54) X54))) (let ((X56 Bool (or X53 X51))) (let ((X57 Bool (and (= X55 6) (and (= X52 0) (not X56))))) (let ((X58 -Int (ite X57 -(ite (= X55 6) 3 X55) X55))) (let ((X59 -Int (ite X57 -(ite (not -(= X58 4)) 4 X58) X58))) (let ((X60 Bool -(or X57 X56))) (let ((X61 Bool -(and (= X59 5) (and (= X47 0) (not X60))))) (let ((X62 -Int (ite X61 -(ite (= X59 5) 3 X59) X59))) (let ((X63 -Int (ite X61 -(ite (not -(= X62 4)) 4 X62) X62))) (and (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ true) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep X2 -(ite (and (not X17) (and (>= X16 2) (<= X16 -8))) (ite (and (not X43) (and (>= X42 -3) (<= X42 -6))) X63 X42) X16)) X1)) (<= 0 X47 1) (<= 0 X22 1) (<= 0 X18 1) (<= 0 X7 1) (<= 0 X52 1) top.res.init_flag)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ) -(define-fun trans ( - -;; Current state. -(top.usr.onOff Bool) (top.usr.decelSet Bool) (top.usr.accelResume Bool) (top.usr.cancel Bool) (top.usr.brakePedal Bool) (top.usr.carGear Int) (top.usr.carSpeed Real) (top.usr.validInputs Bool) (top.usr.OK Bool) (top.res.init_flag Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out Int) -;; Next state. -(top.usr.onOff! Bool) (top.usr.decelSet! Bool) (top.usr.accelResume! Bool) (top.usr.cancel! Bool) (top.usr.brakePedal! Bool) (top.usr.carGear! Int) (top.usr.carSpeed! Real) (top.usr.validInputs! Bool) (top.usr.OK! Bool) (top.res.init_flag! Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___! Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep! Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root! Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out! Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out! Int) -) Bool - -(let ((X1 -Int top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root)) (let ((X2 Int (ite (not (= X1 1)) 1 X1))) (let ((X3 Bool (or (= X2 1) (and (>= X2 2) (<= X2 8))))) (and (= top.usr.OK! X3) (let ((X4 Bool (and (not top.usr.decelSet) top.usr.decelSet!))) (let ((X5 Bool (and (and (and (and (not top.usr.cancel!) (not top.usr.brakePedal!)) (ite (= top.usr.carGear! 3) true false)) (ite (>= top.usr.carSpeed! 15.0) true false)) top.usr.validInputs!))) (let ((X6 Bool (and (not top.usr.accelResume) top.usr.accelResume!))) (and (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out! -(ite (<= (ite (>= 0 -(ite top.usr.decelSet! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out 1) 0)) 0 -(ite top.usr.decelSet! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out 1) 0)) 20) (ite (>= 0 -(ite top.usr.decelSet! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out 1) 0)) 0 -(ite top.usr.decelSet! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out 1) 0)) 20)) (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out! -(ite (<= (ite (>= 0 -(ite top.usr.accelResume! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out 1) 0)) 0 -(ite top.usr.accelResume! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out 1) 0)) 20) (ite (>= 0 -(ite top.usr.accelResume! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out 1) 0)) 0 -(ite top.usr.accelResume! -(+ top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out 1) 0)) 20)) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep! -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ -false top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep)) (let ((X7 Int (ite (not top.usr.onOff!) 0 1))) (let ((X8 Bool (and (and (>= X1 2) (<= X1 8)) (not (ite (not (= X7 0)) true false))))) (let ((X9 Int (ite X8 (ite (and (>= X1 2) (<= X1 8)) 0 X1) X1))) (let ((X10 Int (ite X8 (ite (not (= X9 1)) 1 X9) X9))) (let ((X11 Bool (and (= X10 1) (and (ite (not (= X7 0)) true false) (not X8))))) (let ((X12 Int (ite X11 (ite (= X10 1) 0 X10) X10))) (let ((X13 Int (ite (not (and (>= X12 2) (<= X12 8))) 2 X12))) (let ((X14 Bool (and (not (and (>= X12 2) (<= X12 8))) (and (>= X13 2) (<= X13 8))))) (let ((X15 Int (ite X14 (ite (not (= X13 7)) 7 X13) X13))) (let ((X16 Int (ite X11 X15 X12))) (let ((X17 Bool (or X11 X8))) (let ((X18 Int (ite (not X5) 0 1))) (let ((X19 Bool (and (and (>= X16 3) (<= X16 6)) (not (ite (not (= X18 0)) true false))))) (let ((X20 -Int (ite X19 -(ite (and (>= X16 3) (<= X16 6)) 2 X16) X16))) (let ((X21 Int (ite X19 (ite (not (= X20 8)) 8 X20) X20))) (let ((X22 Int (ite (not X4) 0 1))) (let ((X23 Bool (and (= X21 8) (and (and (ite (not (= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not (= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X19))))) (let ((X24 Int (ite X23 (ite (= X21 8) 2 X21) X21))) (let ((X25 -Int (ite (not (and (>= X24 3) (<= X24 6))) 3 X24))) (let ((X26 Bool (and (not (and (>= X24 3) (<= X24 6))) (and (>= X25 3) (<= X25 6))))) (let ((X27 -Int (ite X26 -(ite (not (= X25 4)) 4 X25) X25))) (let ((X28 Int (ite X23 X27 X24))) (let ((X29 Bool (or X23 X19))) (let ((X30 Bool (and (= X28 8) (and (and (ite (not -(= (ite (not -(= (ite (not X6) 0 1) 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X29))))) (let ((X31 -Int (ite X30 (ite (= X28 8) 2 X28) X28))) (let ((X32 -Int (ite (not (and (>= X31 3) (<= X31 6))) 3 X31))) (let ((X33 Bool (and (not -(and (>= X31 3) (<= X31 6))) (and (>= X32 3) (<= X32 6))))) (let ((X34 -Int (ite X33 -(ite (not (= X32 4)) 4 X32) X32))) (let ((X35 Int (ite X30 X34 X31))) (let ((X36 Bool (or X30 X29))) (let ((X37 Bool (and (= X35 7) (and (and (ite (not -(= (ite (not (= X22 1)) 0 1) 0)) true false) (ite (not -(= (ite (not (= X18 1)) 0 1) 0)) true false)) (not X36))))) (let ((X38 -Int (ite X37 -(ite (= X35 7) 2 X35) X35))) (let ((X39 -Int (ite (not -(and (>= X38 3) (<= X38 6))) 3 X38))) (let ((X40 Bool (and (not -(and (>= X38 3) (<= X38 6))) (and (>= X39 3) (<= X39 6))))) (let ((X41 -Int (ite X40 -(ite (not (= X39 4)) 4 X39) X39))) (let ((X42 Int (ite X37 X41 X38))) (let ((X43 Bool (or X37 X36))) (let ((X44 Bool (and (= X42 4) (= X22 1)))) (let ((X45 -Int (ite X44 -(ite (= X42 4) 3 X42) X42))) (let ((X46 -Int (ite X44 -(ite (not (= X45 4)) 4 X45) X45))) (let ((X47 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out! 20) true false)) 0 1))) (let ((X48 Bool (and (= X46 4) (and (= X47 1) (not X44))))) (let ((X49 -Int (ite X48 -(ite (= X46 4) 3 X46) X46))) (let ((X50 -Int (ite X48 -(ite (not (= X49 5)) 5 X49) X49))) (let ((X51 Bool (or X48 X44))) (let ((X52 -Int (ite (not -(ite (= top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out! 20) true false)) 0 1))) (let ((X53 Bool (and (= X50 4) (and (= X52 1) (not X51))))) (let ((X54 -Int (ite X53 -(ite (= X50 4) 3 X50) X50))) (let ((X55 -Int (ite X53 -(ite (not -(= X54 6)) 6 X54) X54))) (let ((X56 Bool (or X53 X51))) (let ((X57 Bool (and (= X55 6) (and (= X52 0) (not X56))))) (let ((X58 -Int (ite X57 -(ite (= X55 6) 3 X55) X55))) (let ((X59 -Int (ite X57 -(ite (not -(= X58 4)) 4 X58) X58))) (let ((X60 Bool -(or X57 X56))) (let ((X61 Bool -(and (= X59 5) (and (= X47 0) (not X60))))) (let ((X62 -Int (ite X61 -(ite (= X59 5) 3 X59) X59))) (let ((X63 -Int (ite X61 -(ite (not -(= X62 4)) 4 X62) X62))) (and (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___! true) (= top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root! -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___! -(ite top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep! X2 -(ite (and (not X17) (and (>= X16 2) (<= X16 -8))) (ite (and (not X43) (and (>= X42 -3) (<= X42 -6))) X63 X42) X16)) X1)) (<= 0 X47 1) (<= 0 X22 1) (<= 0 X18 1) (<= 0 X7 1) (<= 0 X52 1) (not top.res.init_flag!))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ) -(define-fun -prop ( -(top.usr.onOff Bool) (top.usr.decelSet Bool) (top.usr.accelResume Bool) (top.usr.cancel Bool) (top.usr.brakePedal Bool) (top.usr.carGear Int) (top.usr.carSpeed Real) (top.usr.validInputs Bool) (top.usr.OK Bool) (top.res.init_flag Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic____wakeup___ Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_rlt_evtInitStep Bool) (top.impl.usr.chart_CruiseController_ModeLogic_mode_logic_final_state_states___root Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetAccel_Bounded_Count_Out Int) (top.impl.usr.cruise_controller_CruiseController_ModeLogic_DelayOnsetDecel_Bounded_Count_Out Int) ) Bool - top.usr.OK -) -(inv-constraint str_invariant init trans prop) -(check-synth) diff --git a/test/regress/regress1/sygus/max.sy b/test/regress/regress1/sygus/max.sy new file mode 100644 index 000000000..37ed848ef --- /dev/null +++ b/test/regress/regress1/sygus/max.sy @@ -0,0 +1,33 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic LIA) + +(synth-fun max ((x Int) (y Int)) Int + ((Start Int (0 1 x y + (+ Start Start) + (- Start Start) + (ite StartBool Start Start))) + (StartBool Bool ((and StartBool StartBool) + (not StartBool) + (<= Start Start))))) + +;(synth-fun min ((x Int) (y Int)) Int +; ((Start Int ((Constant Int) (Variable Int) +; (+ Start Start) +; (- Start Start) +; (ite StartBool Start Start))) +; (StartBool Bool ((and StartBool StartBool) +; (not StartBool) +; (<= Start Start))))) + +(declare-var x Int) +(declare-var y Int) + +(constraint (>= (max x y) x)) +(constraint (>= (max x y) y)) +(constraint (or (= x (max x y)) + (= y (max x y)))) +;(constraint (= (+ (max x y) (min x y)) +; (+ x y))) + +(check-synth) diff --git a/test/regress/regress1/sygus/mpg_guard1-dd.sy b/test/regress/regress1/sygus/mpg_guard1-dd.sy deleted file mode 100644 index 31800a36f..000000000 --- a/test/regress/regress1/sygus/mpg_guard1-dd.sy +++ /dev/null @@ -1,27 +0,0 @@ -; EXPECT: unsat -; COMMAND-LINE: --sygus-out=status -(set-logic LIA) - -(synth-fun eq1 ( (x Int) (y Int) ) Int - ((Start Int (x - y - 0 - (+ Start Start) - (- Start Start) - (ite StartBool Start Start))) - (StartBool Bool ((and StartBool StartBool) - (<= Start Start) - (= Start Start))))) - -(define-fun iteB (( b1 Bool ) (b2 Bool ) (b3 Bool )) Bool (or (and b1 b2) (and (not b1) b3))) - -(declare-var x Int) -(declare-var y Int) - -(constraint (iteB (>= x 0) - (= (eq1 x y) (+ x x)) - (= (eq1 x y) x) -)) - -(check-synth) - diff --git a/test/regress/regress1/sygus/multi-fun-polynomial2.sy b/test/regress/regress1/sygus/multi-fun-polynomial2.sy new file mode 100644 index 000000000..22a2e0a4b --- /dev/null +++ b/test/regress/regress1/sygus/multi-fun-polynomial2.sy @@ -0,0 +1,35 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status + +(set-logic LIA) + +(synth-fun addExpr1 ((x Int) (y Int)) Int + ((Start Int (x + y + 0 + 1 + (+ Start Start) + (- Start Start) + )) + )) + +(synth-fun addExpr2 ((x Int) (y Int)) Int + ((Start Int (x + y + 0 + 1 + (+ Start Start) + (- Start Start) + )) + )) + + +(declare-var x Int) +(declare-var y Int) + +(constraint (= (+ (addExpr1 x y) (addExpr2 y x)) (- x y))) + + +(check-synth) + +; (x, y), (x-y, 0) ... are valid solutions diff --git a/test/regress/regress1/sygus/nflat-fwd-3.sy b/test/regress/regress1/sygus/nflat-fwd-3.sy new file mode 100644 index 000000000..a1776cf93 --- /dev/null +++ b/test/regress/regress1/sygus/nflat-fwd-3.sy @@ -0,0 +1,11 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic LIA) +(synth-fun f ((x Int)) Int + ((Start Int ((+ (+ Con Con) Con) x)) + (Con Int (0 1)))) + +(declare-var x Int) +(constraint (= (f x) 2)) +(check-synth) + diff --git a/test/regress/regress1/sygus/nflat-fwd.sy b/test/regress/regress1/sygus/nflat-fwd.sy new file mode 100644 index 000000000..da26a6c93 --- /dev/null +++ b/test/regress/regress1/sygus/nflat-fwd.sy @@ -0,0 +1,11 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic LIA) +(synth-fun f ((x Int)) Int + ((Start Int ((+ Con Con) (+ (+ Start Start) Con) x)) + (Con Int (0 1)))) + +(declare-var x Int) +(constraint (= (f x) (* 2 x))) +(check-synth) + diff --git a/test/regress/regress1/sygus/nia-max-square-ns.sy b/test/regress/regress1/sygus/nia-max-square-ns.sy new file mode 100644 index 000000000..6e7f70ff0 --- /dev/null +++ b/test/regress/regress1/sygus/nia-max-square-ns.sy @@ -0,0 +1,13 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status --nl-ext-tplanes +(set-logic NIA) + +(synth-fun max ((x Int) (y Int)) Int) + +(declare-var x Int) +(declare-var y Int) + +(constraint (>= (max x y) (* x x))) +(constraint (>= (max x y) (* y y))) + +(check-synth) diff --git a/test/regress/regress1/sygus/nia-max-square.sy b/test/regress/regress1/sygus/nia-max-square.sy deleted file mode 100644 index e023e837b..000000000 --- a/test/regress/regress1/sygus/nia-max-square.sy +++ /dev/null @@ -1,21 +0,0 @@ -; EXPECT: unsat -; COMMAND-LINE: --sygus-out=status --nl-ext-tplanes -(set-logic NIA) - -(synth-fun max ((x Int) (y Int)) Int - ((Start Int (0 1 x y - (+ Start Start) - (- Start Start) - (* Start Start) - (ite StartBool Start Start))) - (StartBool Bool ((and StartBool StartBool) - (not StartBool) - (<= Start Start))))) - -(declare-var x Int) -(declare-var y Int) - -(constraint (>= (max x y) (* x x))) -(constraint (>= (max x y) (* y y))) - -(check-synth) diff --git a/test/regress/regress1/sygus/no-flat-simp.sy b/test/regress/regress1/sygus/no-flat-simp.sy new file mode 100644 index 000000000..c0f0e4c0f --- /dev/null +++ b/test/regress/regress1/sygus/no-flat-simp.sy @@ -0,0 +1,20 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status + +(set-logic LIA) + +(synth-fun f ((x Int) (y Int)) Int + ((Start Int (x + y + 0 + (- Start Start) + (+ Start (+ Start Start)))))) + +(declare-var x Int) +(declare-var y Int) + +(constraint (= (f x y) (+ x y))) + + +(check-synth) + diff --git a/test/regress/regress1/sygus/no-mention.sy b/test/regress/regress1/sygus/no-mention.sy new file mode 100644 index 000000000..f964d6039 --- /dev/null +++ b/test/regress/regress1/sygus/no-mention.sy @@ -0,0 +1,15 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic LIA) + +(synth-fun p ((x Int) (y Int)) Int) +(synth-fun m ((x Int) (y Int)) Int) +(synth-fun n ((x Int)) Int) + +(declare-var x Int) +(declare-var y Int) + +(constraint (>= (m x y) x)) + +(check-synth) + diff --git a/test/regress/regress1/sygus/process-10-vars.sy b/test/regress/regress1/sygus/process-10-vars.sy new file mode 100644 index 000000000..523abd70d --- /dev/null +++ b/test/regress/regress1/sygus/process-10-vars.sy @@ -0,0 +1,24 @@ +; COMMAND-LINE: --cegqi-si=none --sygus-out=status +; EXPECT: unsat +(set-logic LIA) + +(synth-fun f ((x1 Int) (x2 Int) (x3 Int) (x4 Int) (x5 Int) (x6 Int) (x7 Int) (x8 Int) (x9 Int) (x10 Int)) Int) + + +(declare-var x1 Int) +(declare-var x2 Int) +(declare-var x3 Int) +(declare-var x4 Int) +(declare-var x5 Int) +(declare-var x6 Int) +(declare-var x7 Int) +(declare-var x8 Int) +(declare-var x9 Int) +(declare-var x10 Int) + +; should be able to determine that arguments 1...6, 8...10 are irrelevant for f + +(constraint (>= (f x1 x2 x3 x4 x5 x6 x7 x8 x9 x10) (+ x7 x7 x7))) + +(check-synth) + diff --git a/test/regress/regress1/sygus/process-arg-invariance.sy b/test/regress/regress1/sygus/process-arg-invariance.sy deleted file mode 100644 index 3c18b6c75..000000000 --- a/test/regress/regress1/sygus/process-arg-invariance.sy +++ /dev/null @@ -1,18 +0,0 @@ -; COMMAND-LINE: --cegqi-si=none --sygus-out=status --no-sygus-add-const-grammar -; EXPECT: unsat -(set-logic LIA) - -(synth-fun f ((x1 Int) (x2 Int) (x3 Int) (x4 Int) (x5 Int) (x6 Int) (x7 Int) (x8 Int) (x9 Int) (x10 Int)) Int) - - -(declare-var x Int) -(declare-var y Int) - -; should be able to determine that only 3 arguments -; (one of 5...9, one of 1 or 4, one of 2 or 3) is relevant for f - -(constraint (> (f (+ x x) (+ x 1) (+ x 1) (+ x x) x x x x x 0) (+ x x x))) -(constraint (<= (f x x x x x x x x x 0) (+ x x x))) - -(check-synth) - diff --git a/test/regress/regress1/sygus/qe.sy b/test/regress/regress1/sygus/qe.sy new file mode 100644 index 000000000..77e16efcb --- /dev/null +++ b/test/regress/regress1/sygus/qe.sy @@ -0,0 +1,12 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status --sygus-qe-preproc +(set-logic LIA) + +(synth-fun f ((x Int)) Int) + +(declare-var x Int) +(declare-var y Int) + +(constraint (=> (or (= y 2) (= y 3)) (> (f x) y))) + +(check-synth) diff --git a/test/regress/regress1/sygus/strings-concat-3-args.sy b/test/regress/regress1/sygus/strings-concat-3-args.sy new file mode 100644 index 000000000..6628ff746 --- /dev/null +++ b/test/regress/regress1/sygus/strings-concat-3-args.sy @@ -0,0 +1,18 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) +(synth-fun f ((x String)) String +((Start String (ntString)) + +(ntString String (x "" (str.++ ntStringConst ntString ntString))) + +(ntStringConst String ("a" "b" " ")) + +)) + +; can be solved with concat PBE strategy, although we currently are not (issue #1259) +; regardless, this is small enough to solve quickly +(constraint (= (f "def") "ab def")) + +(check-synth) + diff --git a/test/regress/regress1/sygus/strings-double-rec.sy b/test/regress/regress1/sygus/strings-double-rec.sy new file mode 100644 index 000000000..ea9caadea --- /dev/null +++ b/test/regress/regress1/sygus/strings-double-rec.sy @@ -0,0 +1,16 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) + +(synth-fun f ((name String)) String + ((Start String (name "A" "B" "" (str.++ Start1 Start2))) + (Start1 String (name "A" "B" "")) + (Start2 String (name "B" "A" (str.++ Start2 Start))) +)) + + +(declare-var name String) + +(constraint (= (f "BB") "AAAAAAAAAAAA")) + +(check-synth) diff --git a/test/regress/regress1/sygus/strings-small.sy b/test/regress/regress1/sygus/strings-small.sy new file mode 100644 index 000000000..7d976ff39 --- /dev/null +++ b/test/regress/regress1/sygus/strings-small.sy @@ -0,0 +1,35 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) +(synth-fun f ((firstname String) (lastname String)) String +((Start String (ntString)) + +(ntString String ( +firstname +lastname +" " +(str.++ ntString ntString))) + +(ntInt Int ( +0 +1 +2 +(+ ntInt ntInt) +(- ntInt ntInt) +(str.len ntString) +(str.to.int ntString) +(str.indexof ntString ntString ntInt))) + +(ntBool Bool ( +true +false +(str.prefixof ntString ntString) +(str.suffixof ntString ntString) +(str.contains ntString ntString))) + +)) + +(constraint (= (f "Nancy" "FreeHafer") "Nancy FreeHafer")) + +(check-synth) + diff --git a/test/regress/regress1/sygus/strings-template-infer-unused.sy b/test/regress/regress1/sygus/strings-template-infer-unused.sy new file mode 100644 index 000000000..d0bee5564 --- /dev/null +++ b/test/regress/regress1/sygus/strings-template-infer-unused.sy @@ -0,0 +1,16 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) + +(define-fun cA ((x String) (w String) (y String) (z String)) String (str.++ (str.++ x "A") y)) + +(synth-fun f ((name String)) String + ((Start String (name "A" "B" "" + (cA Start Start Start Start))))) + + +(declare-var name String) + +(constraint (= (f "BB") "AAAAAAAAAAAA")) + +(check-synth) diff --git a/test/regress/regress1/sygus/strings-template-infer.sy b/test/regress/regress1/sygus/strings-template-infer.sy new file mode 100644 index 000000000..13c4d7dac --- /dev/null +++ b/test/regress/regress1/sygus/strings-template-infer.sy @@ -0,0 +1,16 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) + +(define-fun cA ((x String) (y String)) String (str.++ (str.++ x "A") y)) + +(synth-fun f ((name String)) String + ((Start String (name "A" "B" "" + (cA Start Start))))) + + +(declare-var name String) + +(constraint (= (f "BB") "AAAAAAAAAAAA")) + +(check-synth) diff --git a/test/regress/regress1/sygus/strings-trivial-simp.sy b/test/regress/regress1/sygus/strings-trivial-simp.sy new file mode 100644 index 000000000..f5e41a8f5 --- /dev/null +++ b/test/regress/regress1/sygus/strings-trivial-simp.sy @@ -0,0 +1,14 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) + +(synth-fun f ((name String)) String + ((Start String (name "A" "B" + (str.++ Start Start))))) + + +(declare-var name String) + +(constraint (= (f "BB") "AAAAAAAAAAAABAAAAAAAABAAA")) + +(check-synth) diff --git a/test/regress/regress1/sygus/strings-trivial-two-type.sy b/test/regress/regress1/sygus/strings-trivial-two-type.sy new file mode 100644 index 000000000..86c71aa3a --- /dev/null +++ b/test/regress/regress1/sygus/strings-trivial-two-type.sy @@ -0,0 +1,18 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) + +(synth-fun f ((name String)) String + ((Start String (ntString)) + (ntString String (name "B" "" + (str.++ ntStringC ntString))) + (ntStringC String (name "A" "")) + + )) + + +(declare-var name String) + +(constraint (= (f "B") "AAAAAAAAAAAAAAAAAAAAAAAAA")) + +(check-synth) diff --git a/test/regress/regress1/sygus/strings-trivial.sy b/test/regress/regress1/sygus/strings-trivial.sy new file mode 100644 index 000000000..9af0a1bb1 --- /dev/null +++ b/test/regress/regress1/sygus/strings-trivial.sy @@ -0,0 +1,15 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic SLIA) + +(synth-fun f ((name String)) String + ((Start String (ntString)) + (ntString String (name "A" "B" + (str.++ ntString ntString))))) + + +(declare-var name String) + +(constraint (= (f "B") "AAAAAAAAAAAAAAAAAAAAAAAAA")) + +(check-synth) diff --git a/test/regress/regress1/sygus/sygus-dt.sy b/test/regress/regress1/sygus/sygus-dt.sy new file mode 100644 index 000000000..d496e3fdc --- /dev/null +++ b/test/regress/regress1/sygus/sygus-dt.sy @@ -0,0 +1,16 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status + +(set-logic LIA) + +(declare-datatypes ((List 0)) (((cons (head Int) (tail List)) (nil)))) +(define-fun g ((x Int)) List (cons (+ x 1) nil)) +(define-fun i () List (cons 3 nil)) + +(synth-fun f ((x Int)) List ((Start List ((g StartInt) i (cons StartInt Start) (nil) (tail Start))) + (StartInt Int (x 0 1 (+ StartInt StartInt))))) + +(declare-var x Int) + +(constraint (= (f x) (cons x nil))) +(check-synth) diff --git a/test/regress/regress1/sygus/three.sy b/test/regress/regress1/sygus/three.sy deleted file mode 100644 index 831e5beb1..000000000 --- a/test/regress/regress1/sygus/three.sy +++ /dev/null @@ -1,30 +0,0 @@ -; EXPECT: unsat -; COMMAND-LINE: --sygus-out=status - -(set-logic LIA) - -(synth-fun f ((x Int)) Int - ((Start Int ( - x - 3 - 7 - 10 - (* Start Start) - (mod Start Start))))) - -(declare-var x Int) - -(constraint (= (f x) (f (+ x 10)))) -(constraint (= (f 1) 3)) -(constraint (= (f 2) 6)) -(constraint (= (f 3) 9)) -(constraint (= (f 4) 2)) -(constraint (= (f 5) 5)) -(constraint (= (f 6) 8)) -(constraint (= (f 7) 1)) -(constraint (= (f 8) 4)) -(constraint (= (f 9) 7)) -(constraint (= (f 0) 0)) - -(check-synth) - diff --git a/test/regress/regress1/sygus/tl-type-0.sy b/test/regress/regress1/sygus/tl-type-0.sy new file mode 100644 index 000000000..ceda89d78 --- /dev/null +++ b/test/regress/regress1/sygus/tl-type-0.sy @@ -0,0 +1,11 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=none --sygus-out=status +(set-logic LIA) +(synth-fun f ((x Int)) Int + ((Start Int ((+ Term Term))) + (Term Int (x 0)))) + +(declare-var x Int) +(constraint (= (f x) 0)) +(check-synth) + diff --git a/test/regress/regress1/sygus/tl-type-4x.sy b/test/regress/regress1/sygus/tl-type-4x.sy new file mode 100644 index 000000000..bf8eee5ee --- /dev/null +++ b/test/regress/regress1/sygus/tl-type-4x.sy @@ -0,0 +1,11 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=none --sygus-out=status +(set-logic LIA) +(synth-fun f ((x Int)) Int + ((Start Int (Term (+ Start Start))) + (Term Int (x 0)))) + +(declare-var x Int) +(constraint (= (f x) (* 4 x))) +(check-synth) + diff --git a/test/regress/regress1/sygus/tl-type.sy b/test/regress/regress1/sygus/tl-type.sy new file mode 100644 index 000000000..6f25a570e --- /dev/null +++ b/test/regress/regress1/sygus/tl-type.sy @@ -0,0 +1,11 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=none --sygus-out=status +(set-logic LIA) +(synth-fun f ((x Int)) Int + ((Start Int (Term (+ Start Start))) + (Term Int (x 0)))) + +(declare-var x Int) +(constraint (= (f x) (* 3 x))) +(check-synth) + diff --git a/test/regress/regress1/sygus/triv-type-mismatch-si.sy b/test/regress/regress1/sygus/triv-type-mismatch-si.sy new file mode 100644 index 000000000..37c5a7f53 --- /dev/null +++ b/test/regress/regress1/sygus/triv-type-mismatch-si.sy @@ -0,0 +1,13 @@ +; EXPECT: unsat +; COMMAND-LINE: --sygus-out=status +(set-logic LIA) + +(synth-fun R ((y Int)) Bool) +(synth-fun e () Int) + +(declare-var x Int) + +(constraint (=> (= x e) (R x))) + +(check-synth) + diff --git a/test/regress/regress1/sygus/twolets1.sy b/test/regress/regress1/sygus/twolets1.sy new file mode 100644 index 000000000..06d2ecb71 --- /dev/null +++ b/test/regress/regress1/sygus/twolets1.sy @@ -0,0 +1,40 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic LIA) + +;; f1 is x plus 2 ;; f2 is 2x plus 5 + +(define-fun let0 ((x Int) (y Int) (z Int)) Int (+ (+ y x) z)) + +(synth-fun f1 ((x Int)) Int + ( + (Start Int ( + (let0 Intx CInt CInt) + ) + ) + (Intx Int (x)) + (CInt Int (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + + ) +) + +(synth-fun f2 ((x Int)) Int + ( + (Start Int (x + (let0 Intx Start CInt) + ) + ) + (Intx Int (x)) + (CInt Int (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + + ) +) + + +(declare-var x Int) + +(constraint (= (+ (f1 x)(f2 x)) (+ (+ x x) (+ x 8)))) +(constraint (= (- (f2 x)(f1 x)) (+ x 2))) + +(check-synth) + diff --git a/test/regress/regress1/sygus/twolets2-orig.sy b/test/regress/regress1/sygus/twolets2-orig.sy new file mode 100644 index 000000000..50f7ad544 --- /dev/null +++ b/test/regress/regress1/sygus/twolets2-orig.sy @@ -0,0 +1,28 @@ +; EXPECT: unsat +; COMMAND-LINE: --cegqi-si=all --sygus-out=status +(set-logic LIA) +(synth-fun f1 ((x Int)) Int + ( + (Start Int ( + (let ((y Int CInt) (z Int CInt)) (+ (+ y x) z)) + ) + ) + (CInt Int (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + + ) +) +(synth-fun f2 ((x Int)) Int + ( + (Start Int (x + (let ((y Int Start) (z Int CInt)) (+ (+ y x) z)) + ) + ) + (CInt Int (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + + ) +) +(declare-var x1 Int) +(declare-var x2 Int) +(constraint (= (+ (f1 x1)(f2 x2)) (+ (+ x2 x2) (+ x1 8)))) +(check-synth) + diff --git a/test/regress/regress1/sygus/inv_gen_n_c11.sy b/test/regress/regress1/sygus/unbdd_inv_gen_winf1.sy index 9e04682a5..d45cec38b 100644 --- a/test/regress/regress1/sygus/inv_gen_n_c11.sy +++ b/test/regress/regress1/sygus/unbdd_inv_gen_winf1.sy @@ -1,7 +1,8 @@ ; EXPECT: unsat ; COMMAND-LINE: --sygus-out=status + (set-logic LIA) -(synth-fun inv ((i Int) (l Int)) Bool +(synth-fun inv ((x Int)) Bool ( (Start Bool ((and AtomicFormula AtomicFormula) (or AtomicFormula AtomicFormula))) @@ -9,8 +10,8 @@ (Sum Int ((+ Term Term))) (Term Int ((* Sign Var))) (Sign Int (0 1 -1)) - (Var Int (i l)) - (Const Int (-7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7)) + (Var Int (x)) + (Const Int ((+ Const Const) (- Const Const) 0 1)) ) ) @@ -23,14 +24,13 @@ (define-fun or4 ((b1 Bool) (b2 Bool) (b3 Bool) (b4 Bool)) Bool (or (or3 b1 b2 b3) b4)) (define-fun or5 ((b1 Bool) (b2 Bool) (b3 Bool) (b4 Bool) (b5 Bool)) Bool (or (or4 b1 b2 b3 b4) b5)) -(declare-var i Int) -(declare-var l Int) -(declare-var i1 Int) -(declare-var l1 Int) -(declare-var l2 Int) +(declare-var s Int) + +(declare-var x Int) -(constraint (implies (= l 0) (inv i l))) -(constraint (implies (and5 (inv i l) (implies (= l 4) (= l1 0)) (implies (not (= l 4)) (= l1 l)) (not (or (< l1 0) (>= l1 5))) (= l2 (+ l1 1))) (inv i l2))) -(constraint (implies (and4 (inv i l) (implies (= l 4) (= l1 0)) (implies (not (= l 4)) (= l1 l)) (or (< l1 0) (>= l1 5))) false)) +(constraint (implies (= x 0) (inv x))) +(constraint (implies (inv x) (= x 0))) +(constraint (implies (inv x) (inv x))) +(constraint (implies (and (inv x) false) (not (= x 0)))) (check-synth) diff --git a/test/regress/regress1/test12.cvc b/test/regress/regress1/test12.cvc new file mode 100644 index 000000000..37687bee1 --- /dev/null +++ b/test/regress/regress1/test12.cvc @@ -0,0 +1,178 @@ +% COMMAND-LINE: --incremental +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: valid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: valid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: invalid +% EXPECT: valid +% EXPECT: valid +% EXPECT: valid +A: TYPE; +P_1: BOOLEAN; +P_2: BOOLEAN; +P_3: BOOLEAN; +ASSERT (NOT P_1 OR P_2 OR P_2); +ASSERT (NOT P_1 OR P_2 OR P_3); +P_4: BOOLEAN; +P_5: BOOLEAN; +ASSERT (NOT P_1 OR NOT P_4 OR P_2); +ASSERT (NOT P_1 OR NOT P_5 OR P_2); +P_6: BOOLEAN; +P_7: BOOLEAN; +ASSERT (NOT P_2 OR P_6 OR P_1); +ASSERT (NOT P_2 OR P_7 OR P_1); +P_8: BOOLEAN; +P_9: BOOLEAN; +ASSERT (NOT P_2 OR NOT P_8 OR P_1); +ASSERT (NOT P_2 OR NOT P_9 OR P_1); +P_10: BOOLEAN; +ASSERT (P_2 OR P_1 OR P_4); +ASSERT (P_2 OR P_1 OR P_10); +ASSERT (NOT P_2 OR NOT P_1 OR P_4); +ASSERT (NOT P_2 OR NOT P_1 OR P_10); +P_11: BOOLEAN; +ASSERT (NOT P_6 OR P_2 OR P_1); +ASSERT (NOT P_11 OR P_2 OR P_1); +ASSERT (NOT P_6 OR NOT P_2 OR NOT P_1); +ASSERT (NOT P_11 OR NOT P_2 OR NOT P_1); +PUSH; +QUERY (NOT P_2 OR NOT P_3); +POP; +PUSH; +QUERY (P_1 OR NOT P_3); +POP; +PUSH; +QUERY (NOT P_2 OR P_1); +POP; +PUSH; +QUERY (P_5 OR NOT P_2); +POP; +PUSH; +QUERY (P_1 OR NOT P_2); +POP; +PUSH; +QUERY (P_5 OR P_1); +POP; +PUSH; +QUERY (NOT P_7 OR NOT P_1); +POP; +PUSH; +QUERY (P_2 OR NOT P_1); +POP; +PUSH; +QUERY P_2; +POP; +PUSH; +QUERY (P_9 OR NOT P_1); +POP; +PUSH; +QUERY (P_2 OR NOT P_1); +POP; +PUSH; +QUERY P_2; +POP; +PUSH; +QUERY (NOT P_1 OR NOT P_10); +POP; +PUSH; +QUERY (NOT P_2 OR NOT P_10); +POP; +PUSH; +QUERY (NOT P_1 OR NOT P_2); +POP; +PUSH; +QUERY (P_1 OR NOT P_10); +POP; +PUSH; +QUERY (P_2 OR NOT P_10); +POP; +PUSH; +QUERY (P_1 OR P_2); +POP; +PUSH; +QUERY (NOT P_2 OR NOT P_1); +POP; +PUSH; +QUERY (P_11 OR NOT P_1); +POP; +PUSH; +QUERY (NOT P_2 OR P_11); +POP; +PUSH; +QUERY (P_2 OR P_1); +POP; +PUSH; +QUERY (P_11 OR P_1); +POP; +PUSH; +QUERY (P_2 OR P_11); +POP; +P_12: BOOLEAN; +ASSERT (NOT P_12 OR P_2); +ASSERT (NOT P_12 OR P_3); +ASSERT (P_12 OR NOT P_1 OR P_2); +ASSERT (P_12 OR NOT P_1 OR P_2); +P_13: BOOLEAN; +ASSERT (NOT P_13 OR NOT P_4); +ASSERT (NOT P_13 OR NOT P_5); +ASSERT (P_13 OR NOT P_1 OR P_2); +ASSERT (P_13 OR NOT P_1 OR P_2); +ASSERT (NOT P_2 OR P_1); +ASSERT (NOT P_2 OR P_1); +ASSERT (NOT P_2 OR P_1); +ASSERT (NOT P_2 OR P_1); +P_14: BOOLEAN; +ASSERT (P_14 OR P_2 OR P_1); +ASSERT (P_14 OR P_2 OR P_1); +ASSERT (NOT P_14 OR P_4); +ASSERT (NOT P_14 OR P_10); +ASSERT (P_14 OR NOT P_2 OR NOT P_1); +ASSERT (P_14 OR NOT P_2 OR NOT P_1); +P_15: BOOLEAN; +ASSERT (P_15 OR P_2 OR P_1); +ASSERT (P_15 OR P_2 OR P_1); +ASSERT (NOT P_15 OR NOT P_6); +ASSERT (NOT P_15 OR NOT P_11); +ASSERT (P_15 OR NOT P_2 OR NOT P_1); +ASSERT (P_15 OR NOT P_2 OR NOT P_1); +PUSH; +QUERY NOT P_3; +POP; +PUSH; +QUERY P_12; +POP; +PUSH; +QUERY P_11; +POP; +PUSH; +QUERY P_15; +POP; +ASSERT NOT P_15; +ASSERT NOT P_15; +PUSH; +QUERY NOT P_10; +POP; +PUSH; +QUERY FALSE; diff --git a/test/regress/regress1/trim.cvc b/test/regress/regress1/trim.cvc new file mode 100644 index 000000000..8bdbde79a --- /dev/null +++ b/test/regress/regress1/trim.cvc @@ -0,0 +1,36 @@ +% COMMAND-LINE: --finite-model-find +% EXPECT: sat +DATATYPE + myType = A | B +END; +%%% structured datatypes +myTypeSet: TYPE = SET OF myType; +myTypeGammaSet: TYPE = [# pos: myTypeSet, neg: myTypeSet #]; +delta: TYPE = ARRAY myType OF myTypeGammaSet; +labels: TYPE = ARRAY myType OF SET OF STRING; + +%%% the empty myTypes set +emptymyTypeSet : SET OF myType; +ASSERT emptymyTypeSet = {} :: SET OF myType; + +d: delta; +l: labels; + +ASSERT (l[A] = {"L","H"}); +ASSERT (l[B] = {"L"}); + +ic0_i : myTypeSet; +ic0_c : myTypeSet; +ASSERT FORALL (r:myType): + (r IS_IN ic0_i) => FORALL (r2: myType): (r2 IS_IN d[r].neg) => r2 IS_IN ic0_c; +ASSERT {A} <= ic0_i; +ASSERT ((EXISTS (e0 : myType): (e0 IS_IN ic0_i) => (l[A] <= l[e0]))) OR ((ic0_i & ic0_c) <= emptymyTypeSet); + +ic1_i : myTypeSet; +ic1_c : myTypeSet; +ASSERT FORALL (r:myType): + (r IS_IN d[B].pos) => r IS_IN ic1_i; +ASSERT ((EXISTS (e1 : myType): (e1 IS_IN ic1_i) => (l[B] <= l[e1]))) OR ((ic1_i & ic1_c) <= emptymyTypeSet); + +CHECKSAT; +%COUNTEREXAMPLE; diff --git a/test/regress/regress1/uf2.smt2 b/test/regress/regress1/uf2.smt2 new file mode 100644 index 000000000..0aa1617eb --- /dev/null +++ b/test/regress/regress1/uf2.smt2 @@ -0,0 +1,14 @@ +(set-logic QF_AUFBVLIA) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-fun v1 () (_ BitVec 1)) +(declare-fun a2 ((_ BitVec 1)) (_ BitVec 1024)) +(declare-fun v3 () (_ BitVec 1024)) +(declare-fun v4 () (_ BitVec 1024)) +(declare-fun v5 () (_ BitVec 1024)) +(assert (= (a2 (_ bv0 1)) v3)) +(assert (= (a2 (_ bv1 1)) v3)) +(assert (not (= (a2 v1) v3))) +(check-sat) +(exit) diff --git a/test/regress/regress1/uflia/DRAGON_11_e1_2450.ec.minimized.smt2 b/test/regress/regress1/uflia/DRAGON_11_e1_2450.ec.minimized.smt2 new file mode 100644 index 000000000..ab8e5d1da --- /dev/null +++ b/test/regress/regress1/uflia/DRAGON_11_e1_2450.ec.minimized.smt2 @@ -0,0 +1,104 @@ +(set-logic QF_UFLIA) +(declare-fun _base () Int) +(declare-fun _n () Int) +(assert (let ((.def_5 (<= 0 _n))) +.def_5 +)) +(declare-fun ___z2z___ (Int) Bool) +(declare-fun ___z3z___ (Int) Bool) +(declare-fun ___z4z___ (Int) Bool) +(declare-fun ___z5z___ (Int) Bool) +(declare-fun ___z6z___ (Int) Bool) +(declare-fun ___z7z___ (Int) Bool) +(declare-fun ___z8z___ (Int) Bool) +(declare-fun ___z9z___ (Int) Bool) +(declare-fun ___z10z___ (Int) Bool) +(declare-fun ___z11z___ (Int) Bool) +(declare-fun ___z12z___ (Int) Bool) +(declare-fun ___z13z___ (Int) Bool) +(declare-fun ___z14z___ (Int) Int) +(declare-fun ___z15z___ (Int) Bool) +(declare-fun ___z16z___ (Int) Int) +(declare-fun ___z17z___ (Int) Int) +(declare-fun ___z18z___ (Int) Int) +(declare-fun ___z19z___ (Int) Int) +(declare-fun ___z20z___ (Int) Int) +(declare-fun ___z22z___ (Int) Bool) +(declare-fun ___z23z___ (Int) Bool) +(declare-fun ___z24z___ (Int) Bool) +(declare-fun ___z25z___ (Int) Bool) +(declare-fun ___z26z___ (Int) Bool) +(declare-fun ___z27z___ (Int) Bool) +(declare-fun ___z28z___ (Int) Bool) +(declare-fun ___z29z___ (Int) Bool) +(declare-fun ___z30z___ (Int) Bool) +(declare-fun ___z31z___ (Int) Bool) +(declare-fun ___z32z___ (Int) Bool) +(declare-fun ___z33z___ (Int) Bool) +(declare-fun ___z34z___ (Int) Bool) +(declare-fun ___z35z___ (Int) Int) +(declare-fun ___z36z___ (Int) Bool) +(declare-fun ___z37z___ (Int) Int) + + +(assert (let ((.def_1132 (___z29z___ (- 1)))) +(let ((.def_1126 (___z20z___ (- 2)))) +(let ((.def_1127 (<= 1 .def_1126))) +(let ((.def_1124 (___z19z___ (- 2)))) +(let ((.def_1125 (= .def_1124 0))) +(let ((.def_1128 (and .def_1125 .def_1127))) +(let ((.def_1106 (___z17z___ (- 2)))) +(let ((.def_1107 (= .def_1106 0))) +(let ((.def_1129 (and .def_1107 .def_1128))) +(let ((.def_1122 (___z16z___ (- 2)))) +(let ((.def_1123 (= .def_1122 0))) +(let ((.def_1130 (and .def_1123 .def_1129))) +(let ((.def_1108 (___z18z___ (- 2)))) +(let ((.def_1114 (= .def_1108 0))) +(let ((.def_1131 (and .def_1114 .def_1130))) +(let ((.def_1133 (= .def_1131 .def_1132))) +.def_1133 +))))))))))))))))) +(push 1) +(check-sat) +(pop 1) +(assert (let ((.def_2016 (___z16z___ (- 3)))) +(let ((.def_2188 (+ (- 1) .def_2016))) +(let ((.def_2048 (___z34z___ (- 2)))) +(let ((.def_2189 (ite .def_2048 .def_2188 .def_2016))) +(let ((.def_2057 (___z13z___ (- 2)))) +(let ((.def_2190 (ite .def_2057 .def_2189 .def_2016))) +(let ((.def_2036 (___z30z___ (- 2)))) +(let ((.def_2191 (ite .def_2036 0 .def_2016))) +(let ((.def_2064 (___z9z___ (- 2)))) +(let ((.def_2192 (ite .def_2064 .def_2191 .def_2190))) +(let ((.def_2193 (___z25z___ (- 2)))) +(let ((.def_2194 (ite .def_2193 .def_2188 .def_2016))) +(let ((.def_2074 (___z4z___ (- 2)))) +(let ((.def_2195 (ite .def_2074 .def_2194 .def_2192))) +(let ((.def_2196 (___z24z___ (- 2)))) +(let ((.def_2197 (ite .def_2196 0 .def_2016))) +(let ((.def_2076 (___z3z___ (- 2)))) +(let ((.def_2198 (ite .def_2076 .def_2197 .def_2195))) +(let ((.def_2199 (+ 1 .def_2016))) +(let ((.def_2200 (___z23z___ (- 2)))) +(let ((.def_2201 (ite .def_2200 .def_2199 .def_2016))) +(let ((.def_2078 (___z2z___ (- 2)))) +(let ((.def_2202 (ite .def_2078 .def_2201 .def_2198))) +(let ((.def_2052 (= _base (- 2)))) +(let ((.def_2203 (ite .def_2052 0 .def_2202))) +(let ((.def_1122 (___z16z___ (- 2)))) +(let ((.def_2204 (= .def_1122 .def_2203))) +.def_2204 +)))))))))))))))))))))))))))) + +(push 1) +(assert (let ((.def_2052 (= _base (- 2)))) +(let ((.def_2278 (not .def_2052))) +(let ((.def_997 (___z15z___ 0))) +(let ((.def_2290 (or .def_997 .def_2278))) +(let ((.def_2291 (not .def_2290))) +.def_2291 +)))))) +(check-sat) +(pop 1) diff --git a/test/regress/regress1/uflia/DRAGON_11_e1_2450.ec.minimized.smt2.expect b/test/regress/regress1/uflia/DRAGON_11_e1_2450.ec.minimized.smt2.expect new file mode 100644 index 000000000..9403b1a25 --- /dev/null +++ b/test/regress/regress1/uflia/DRAGON_11_e1_2450.ec.minimized.smt2.expect @@ -0,0 +1,3 @@ +% COMMAND-LINE: --incremental +% EXPECT: sat +% EXPECT: sat diff --git a/test/regress/regress1/uflia/FIREFLY_3_e2_2236_e7_3681.ec.core.smt2 b/test/regress/regress1/uflia/FIREFLY_3_e2_2236_e7_3681.ec.core.smt2 new file mode 100644 index 000000000..0274e4390 --- /dev/null +++ b/test/regress/regress1/uflia/FIREFLY_3_e2_2236_e7_3681.ec.core.smt2 @@ -0,0 +1,29 @@ +(set-logic QF_UFLIA) +(set-info :smt-lib-version 2.0) +(declare-fun _base () Int) +(declare-fun _n () Int) +(declare-fun ___z3z___ (Int) Bool) +(declare-fun ___z4z___ (Int) Bool) +(declare-fun ___z6z___ (Int) Bool) +(declare-fun ___z8z___ (Int) Bool) +(declare-fun ___z9z___ (Int) Bool) +(declare-fun ___z11z___ (Int) Bool) +(declare-fun ___z12z___ (Int) Int) +(declare-fun ___z14z___ (Int) Int) +(declare-fun ___z15z___ (Int) Int) +(declare-fun ___z16z___ (Int) Bool) +(declare-fun ___z19z___ (Int) Bool) +(declare-fun ___z20z___ (Int) Bool) +(declare-fun ___z22z___ (Int) Bool) +(declare-fun ___z24z___ (Int) Bool) +(declare-fun ___z25z___ (Int) Bool) +(assert (= (and (<= 1 (+ (___z14z___ (- 1)) (___z15z___ (- 1)))) (<= 1 (___z12z___ (- 1)))) (___z20z___ 0))) +(assert (= (or (not (___z16z___ 0)) (<= 0 (___z15z___ 0))) (___z11z___ 0))) +(assert (let ((?v_2 (___z14z___ (- 1))) (?v_0 (___z15z___ (- 1)))) (let ((?v_1 (+ 2 ?v_0))) (= (___z15z___ 0) (ite (= _base 0) 0 (ite (___z3z___ 0) (ite (___z19z___ 0) ?v_1 ?v_0) (ite (___z4z___ 0) (ite (___z20z___ 0) (+ 1 (+ ?v_2 (+ (- 1) ?v_0))) ?v_0) (ite (___z6z___ 0) (ite (___z22z___ 0) 0 ?v_0) (ite (___z8z___ 0) (ite (___z24z___ 0) ?v_1 ?v_0) (ite (___z9z___ 0) (ite (___z25z___ 0) (+ 1 (+ ?v_2 ?v_0)) ?v_0) ?v_0)))))))))) +(assert (= (and (<= 1 (+ (___z14z___ (- 1)) (___z15z___ (- 1)))) (<= 1 (___z12z___ (- 1)))) (___z25z___ 0))) +(assert (= (or (not (___z16z___ (- 1))) (<= 0 (___z15z___ (- 1)))) (___z11z___ (- 1)))) +(assert (let ((?v_2 (___z14z___ (- 2))) (?v_0 (___z15z___ (- 2)))) (let ((?v_1 (+ 2 ?v_0))) (= (___z15z___ (- 1)) (ite (= _base (- 1)) 0 (ite (___z3z___ (- 1)) (ite (___z19z___ (- 1)) ?v_1 ?v_0) (ite (___z4z___ (- 1)) (ite (___z20z___ (- 1)) (+ 1 (+ ?v_2 (+ (- 1) ?v_0))) ?v_0) (ite (___z6z___ (- 1)) (ite (___z22z___ (- 1)) 0 ?v_0) (ite (___z8z___ (- 1)) (ite (___z24z___ (- 1)) ?v_1 ?v_0) (ite (___z9z___ (- 1)) (ite (___z25z___ (- 1)) (+ 1 (+ ?v_2 ?v_0)) ?v_0) ?v_0)))))))))) +(push 1) +(assert (not (or (not (= _base (- 1))) (and (___z11z___ 0) (___z11z___ (- 1)))))) +(pop 1) +(check-sat) diff --git a/test/regress/regress1/uflia/FIREFLY_3_e2_2236_e7_3681.ec.core.smt2.expect b/test/regress/regress1/uflia/FIREFLY_3_e2_2236_e7_3681.ec.core.smt2.expect new file mode 100644 index 000000000..85c180889 --- /dev/null +++ b/test/regress/regress1/uflia/FIREFLY_3_e2_2236_e7_3681.ec.core.smt2.expect @@ -0,0 +1,2 @@ +% COMMAND-LINE: --incremental +% EXPECT: sat diff --git a/test/regress/regress1/uflia/FIREFLY_luke_1b_e2_3049_e7_1173.ec.minimized.smt2 b/test/regress/regress1/uflia/FIREFLY_luke_1b_e2_3049_e7_1173.ec.minimized.smt2 new file mode 100644 index 000000000..248a056d3 --- /dev/null +++ b/test/regress/regress1/uflia/FIREFLY_luke_1b_e2_3049_e7_1173.ec.minimized.smt2 @@ -0,0 +1,72 @@ +(set-logic QF_UFLIA) +(set-info :smt-lib-version 2.0) +(set-info :status sat) +(declare-fun _base () Int) +(declare-fun _n () Int) +(assert (<= 0 _n)) +(declare-fun ___z2z___ (Int) Bool) +(declare-fun ___z3z___ (Int) Bool) +(declare-fun ___z4z___ (Int) Bool) +(declare-fun ___z5z___ (Int) Bool) +(declare-fun ___z6z___ (Int) Bool) +(declare-fun ___z7z___ (Int) Bool) +(declare-fun ___z8z___ (Int) Bool) +(declare-fun ___z9z___ (Int) Bool) +(declare-fun ___z10z___ (Int) Int) +(declare-fun ___z11z___ (Int) Bool) +(declare-fun ___z12z___ (Int) Int) +(declare-fun ___z13z___ (Int) Int) +(declare-fun ___z14z___ (Int) Int) +(declare-fun ___z15z___ (Int) Int) +(declare-fun ___z16z___ (Int) Bool) +(declare-fun ___z17z___ (Int) Bool) +(declare-fun ___z18z___ (Int) Bool) +(declare-fun ___z19z___ (Int) Bool) +(declare-fun ___z20z___ (Int) Bool) +(declare-fun ___z21z___ (Int) Bool) +(declare-fun ___z22z___ (Int) Bool) +(declare-fun ___z23z___ (Int) Bool) +(declare-fun ___z24z___ (Int) Bool) +(declare-fun ___z25z___ (Int) Int) +(declare-fun ___z26z___ (Int) Bool) +(assert (= (<= 1 (___z14z___ (- 1))) (___z20z___ 0))) +(assert (= (or (not (___z16z___ 0)) (or (= (+ (___z14z___ (- 1)) (+ (___z15z___ (- 1)) (+ (___z13z___ (- 1)) (+ (___z12z___ (- 1)) (+ (* (- 1) (___z15z___ 0)) (+ (* (- 1) (___z14z___ 0)) (+ (* (- 1) (___z13z___ 0)) (* (- 1) (___z12z___ 0))))))))) 0) (= _base 0))) (___z11z___ 0))) +(assert (= (= (___z15z___ (- 1)) 1) (___z21z___ 0))) +(assert (let ((?v_0 (___z12z___ (- 1)))) (let ((?v_1 (+ (- 1) ?v_0))) (= (___z12z___ 0) (ite (= _base 0) (___z25z___ 0) (ite (___z2z___ 0) (ite (___z17z___ 0) ?v_1 ?v_0) (ite (___z3z___ 0) (ite (___z18z___ 0) ?v_1 ?v_0) (ite (___z4z___ 0) (ite (___z19z___ 0) ?v_1 ?v_0) (ite (___z7z___ 0) (ite (___z22z___ 0) ?v_1 ?v_0) (ite (___z8z___ 0) (ite (___z23z___ 0) ?v_1 ?v_0) (ite (___z9z___ 0) (ite (___z24z___ 0) ?v_1 ?v_0) ?v_0))))))))))) +(assert (= (___z22z___ 0) (and (= (___z14z___ (- 1)) 0) (and (= (___z15z___ (- 1)) 0) (and (= (___z13z___ (- 1)) 0) (<= 1 (___z12z___ (- 1)))))))) +(assert (let ((?v_0 (___z13z___ (- 1)))) (let ((?v_1 (+ (- 1) ?v_0))) (= (___z13z___ 0) (ite (= _base 0) 0 (ite (___z3z___ 0) (ite (___z18z___ 0) ?v_1 ?v_0) (ite (___z5z___ 0) (ite (___z20z___ 0) (+ 1 ?v_0) ?v_0) (ite (___z7z___ 0) (ite (___z22z___ 0) 1 ?v_0) (ite (___z8z___ 0) (ite (___z23z___ 0) ?v_1 ?v_0) ?v_0))))))))) +(assert (= (___z23z___ 0) (and (<= 1 (___z12z___ (- 1))) (<= 1 (___z13z___ (- 1)))))) +(assert (let ((?v_0 (___z14z___ (- 1)))) (let ((?v_1 (+ 1 ?v_0))) (= (___z14z___ 0) (ite (= _base 0) 0 (ite (___z2z___ 0) (ite (___z17z___ 0) ?v_1 ?v_0) (ite (___z4z___ 0) (ite (___z19z___ 0) 0 ?v_0) (ite (___z5z___ 0) (ite (___z20z___ 0) (+ (- 1) ?v_0) ?v_0) (ite (___z6z___ 0) (ite (___z21z___ 0) ?v_1 ?v_0) (ite (___z9z___ 0) (ite (___z24z___ 0) 0 ?v_0) ?v_0)))))))))) +(assert (= (___z24z___ 0) (and (<= 1 (___z12z___ (- 1))) (<= 1 (+ (___z14z___ (- 1)) (___z15z___ (- 1))))))) +(assert (let ((?v_2 (___z14z___ (- 1))) (?v_0 (___z15z___ (- 1)))) (let ((?v_1 (+ 2 ?v_0))) (= (___z15z___ 0) (ite (= _base 0) 0 (ite (___z3z___ 0) (ite (___z18z___ 0) ?v_1 ?v_0) (ite (___z4z___ 0) (ite (___z19z___ 0) (+ 1 (+ ?v_2 (+ (- 1) ?v_0))) ?v_0) (ite (___z6z___ 0) (ite (___z21z___ 0) 0 ?v_0) (ite (___z8z___ 0) (ite (___z23z___ 0) ?v_1 ?v_0) (ite (___z9z___ 0) (ite (___z24z___ 0) (+ 1 (+ ?v_2 ?v_0)) ?v_0) ?v_0)))))))))) +(assert (= (___z25z___ 0) (ite (= _base 0) (___z10z___ 0) (___z25z___ (- 1))))) +(assert (let ((?v_0 (= _base 0)) (?v_1 (___z26z___ 0))) (= (___z16z___ 0) (and (or (not ?v_0) ?v_1) (or ?v_0 (or ?v_1 (___z16z___ (- 1)))))))) +(assert (let ((?v_2 (___z9z___ 0)) (?v_0 (___z8z___ 0)) (?v_5 (___z7z___ 0)) (?v_14 (___z4z___ 0)) (?v_17 (___z3z___ 0)) (?v_19 (___z2z___ 0)) (?v_11 (___z5z___ 0)) (?v_8 (___z6z___ 0))) (let ((?v_3 (not ?v_2)) (?v_18 (not ?v_19)) (?v_20 (not ?v_17))) (let ((?v_15 (and ?v_20 ?v_18)) (?v_16 (not ?v_14))) (let ((?v_12 (and ?v_16 ?v_15)) (?v_13 (not ?v_11))) (let ((?v_9 (and ?v_13 ?v_12)) (?v_10 (not ?v_8))) (let ((?v_6 (and ?v_10 ?v_9)) (?v_7 (not ?v_5))) (let ((?v_1 (and ?v_7 ?v_6)) (?v_4 (not ?v_0))) (let ((?v_21 (and ?v_4 ?v_1))) (= (___z26z___ 0) (and (<= 0 (___z10z___ 0)) (or (and ?v_2 ?v_21) (or (and (and ?v_0 ?v_1) ?v_3) (or (and ?v_3 (and ?v_4 (and ?v_5 ?v_6))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_8 ?v_9)))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_11 ?v_12))))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_13 (and ?v_14 ?v_15)))))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_13 (and ?v_16 (and ?v_17 ?v_18))))))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_13 (and ?v_16 (and ?v_19 ?v_20))))))) (and ?v_21 ?v_3)))))))))))))))))))) +(assert (= (___z17z___ 0) (and (= (___z14z___ (- 1)) 0) (and (= (___z15z___ (- 1)) 0) (and (= (___z13z___ (- 1)) 0) (<= 1 (___z12z___ (- 1)))))))) +(assert (= (___z18z___ 0) (and (<= 1 (___z12z___ (- 1))) (<= 1 (___z13z___ (- 1)))))) +(assert (= (___z19z___ 0) (and (<= 1 (___z12z___ (- 1))) (<= 1 (+ (___z14z___ (- 1)) (___z15z___ (- 1))))))) +(assert (= (<= 1 (___z14z___ (- 2))) (___z20z___ (- 1)))) +(assert (= (or (not (___z16z___ (- 1))) (or (= (+ (___z14z___ (- 1)) (+ (___z15z___ (- 1)) (+ (___z13z___ (- 1)) (+ (___z12z___ (- 1)) (+ (* (- 1) (___z14z___ (- 2))) (+ (* (- 1) (___z15z___ (- 2))) (+ (* (- 1) (___z13z___ (- 2))) (* (- 1) (___z12z___ (- 2)))))))))) 0) (= _base (- 1)))) (___z11z___ (- 1)))) +(assert (= (= (___z15z___ (- 2)) 1) (___z21z___ (- 1)))) +(assert (let ((?v_0 (___z12z___ (- 2)))) (let ((?v_1 (+ (- 1) ?v_0))) (= (___z12z___ (- 1)) (ite (= _base (- 1)) (___z25z___ (- 1)) (ite (___z2z___ (- 1)) (ite (___z17z___ (- 1)) ?v_1 ?v_0) (ite (___z3z___ (- 1)) (ite (___z18z___ (- 1)) ?v_1 ?v_0) (ite (___z4z___ (- 1)) (ite (___z19z___ (- 1)) ?v_1 ?v_0) (ite (___z7z___ (- 1)) (ite (___z22z___ (- 1)) ?v_1 ?v_0) (ite (___z8z___ (- 1)) (ite (___z23z___ (- 1)) ?v_1 ?v_0) (ite (___z9z___ (- 1)) (ite (___z24z___ (- 1)) ?v_1 ?v_0) ?v_0))))))))))) +(assert (= (___z22z___ (- 1)) (and (= (___z14z___ (- 2)) 0) (and (= (___z15z___ (- 2)) 0) (and (= (___z13z___ (- 2)) 0) (<= 1 (___z12z___ (- 2)))))))) +(assert (let ((?v_0 (___z13z___ (- 2)))) (let ((?v_1 (+ (- 1) ?v_0))) (= (___z13z___ (- 1)) (ite (= _base (- 1)) 0 (ite (___z3z___ (- 1)) (ite (___z18z___ (- 1)) ?v_1 ?v_0) (ite (___z5z___ (- 1)) (ite (___z20z___ (- 1)) (+ 1 ?v_0) ?v_0) (ite (___z7z___ (- 1)) (ite (___z22z___ (- 1)) 1 ?v_0) (ite (___z8z___ (- 1)) (ite (___z23z___ (- 1)) ?v_1 ?v_0) ?v_0))))))))) +(assert (= (___z23z___ (- 1)) (and (<= 1 (___z12z___ (- 2))) (<= 1 (___z13z___ (- 2)))))) +(assert (let ((?v_0 (___z14z___ (- 2)))) (let ((?v_1 (+ 1 ?v_0))) (= (___z14z___ (- 1)) (ite (= _base (- 1)) 0 (ite (___z2z___ (- 1)) (ite (___z17z___ (- 1)) ?v_1 ?v_0) (ite (___z4z___ (- 1)) (ite (___z19z___ (- 1)) 0 ?v_0) (ite (___z5z___ (- 1)) (ite (___z20z___ (- 1)) (+ (- 1) ?v_0) ?v_0) (ite (___z6z___ (- 1)) (ite (___z21z___ (- 1)) ?v_1 ?v_0) (ite (___z9z___ (- 1)) (ite (___z24z___ (- 1)) 0 ?v_0) ?v_0)))))))))) +(assert (= (___z24z___ (- 1)) (and (<= 1 (___z12z___ (- 2))) (<= 1 (+ (___z14z___ (- 2)) (___z15z___ (- 2))))))) +(assert (let ((?v_2 (___z14z___ (- 2))) (?v_0 (___z15z___ (- 2)))) (let ((?v_1 (+ 2 ?v_0))) (= (___z15z___ (- 1)) (ite (= _base (- 1)) 0 (ite (___z3z___ (- 1)) (ite (___z18z___ (- 1)) ?v_1 ?v_0) (ite (___z4z___ (- 1)) (ite (___z19z___ (- 1)) (+ 1 (+ ?v_2 (+ (- 1) ?v_0))) ?v_0) (ite (___z6z___ (- 1)) (ite (___z21z___ (- 1)) 0 ?v_0) (ite (___z8z___ (- 1)) (ite (___z23z___ (- 1)) ?v_1 ?v_0) (ite (___z9z___ (- 1)) (ite (___z24z___ (- 1)) (+ 1 (+ ?v_2 ?v_0)) ?v_0) ?v_0)))))))))) + +;(assert (= _base (- 1))) +(assert (= (___z25z___ (- 1)) (ite (= _base (- 1)) (___z10z___ (- 1)) (___z25z___ (- 2))))) +;(assert (= (___z25z___ (- 1)) (___z10z___ (- 1)))) +;(assert (= (___z25z___ (- 1)) (___z25z___ (- 2)))) + +(assert (let ((?v_0 (= _base (- 1))) (?v_1 (___z26z___ (- 1)))) (= (___z16z___ (- 1)) (and (or (not ?v_0) ?v_1) (or ?v_0 (or ?v_1 (___z16z___ (- 2)))))))) +(assert (let ((?v_19 (___z2z___ (- 1))) (?v_17 (___z3z___ (- 1))) (?v_14 (___z4z___ (- 1))) (?v_5 (___z7z___ (- 1))) (?v_0 (___z8z___ (- 1))) (?v_2 (___z9z___ (- 1))) (?v_11 (___z5z___ (- 1))) (?v_8 (___z6z___ (- 1)))) (let ((?v_4 (not ?v_0)) (?v_7 (not ?v_5)) (?v_10 (not ?v_8)) (?v_13 (not ?v_11)) (?v_16 (not ?v_14)) (?v_20 (not ?v_17)) (?v_18 (not ?v_19))) (let ((?v_15 (and ?v_20 ?v_18))) (let ((?v_12 (and ?v_16 ?v_15))) (let ((?v_9 (and ?v_13 ?v_12))) (let ((?v_6 (and ?v_10 ?v_9))) (let ((?v_1 (and ?v_7 ?v_6))) (let ((?v_21 (and ?v_4 ?v_1)) (?v_3 (not ?v_2))) (= (___z26z___ (- 1)) (and (<= 0 (___z10z___ (- 1))) (or (and ?v_2 ?v_21) (or (and (and ?v_0 ?v_1) ?v_3) (or (and ?v_3 (and ?v_4 (and ?v_5 ?v_6))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_8 ?v_9)))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_11 ?v_12))))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_13 (and ?v_14 ?v_15)))))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_13 (and ?v_16 (and ?v_17 ?v_18))))))) (or (and ?v_3 (and ?v_4 (and ?v_7 (and ?v_10 (and ?v_13 (and ?v_16 (and ?v_19 ?v_20))))))) (and ?v_21 ?v_3)))))))))))))))))))) +(assert (= (___z17z___ (- 1)) (and (= (___z14z___ (- 2)) 0) (and (= (___z15z___ (- 2)) 0) (and (= (___z13z___ (- 2)) 0) (<= 1 (___z12z___ (- 2)))))))) +(assert (= (___z18z___ (- 1)) (and (<= 1 (___z12z___ (- 2))) (<= 1 (___z13z___ (- 2)))))) +(assert (= (___z19z___ (- 1)) (and (<= 1 (___z12z___ (- 2))) (<= 1 (+ (___z14z___ (- 2)) (___z15z___ (- 2))))))) +(assert (not (or (not (= _base (- 1))) (and (___z11z___ 0) (___z11z___ (- 1)))))) +(assert true) +(check-sat) +(exit) diff --git a/test/regress/regress1/uflia/Makefile.am b/test/regress/regress1/uflia/Makefile.am new file mode 100644 index 000000000..c9a5ee372 --- /dev/null +++ b/test/regress/regress1/uflia/Makefile.am @@ -0,0 +1,41 @@ +# don't override a BINARY imported from a personal.mk +@mk_if@eq ($(BINARY),) +@mk_empty@BINARY = cvc4 +end@mk_if@ + +LOG_COMPILER = @srcdir@/../../run_regression +AM_LOG_FLAGS = $(RUN_REGRESSION_ARGS) @abs_top_builddir@/src/main/$(BINARY)$(EXEEXT) + +if AUTOMAKE_1_11 +# old-style (pre-automake 1.12) test harness +TESTS_ENVIRONMENT = \ + $(LOG_COMPILER) \ + $(AM_LOG_FLAGS) $(LOG_FLAGS) +endif + +# These are run for all build profiles. +# If a test shouldn't be run in e.g. competition mode, +# put it below in "TESTS +=" +TESTS = \ + FIREFLY_luke_1b_e2_3049_e7_1173.ec.minimized.smt2 \ + microwave21.ec.minimized.smt2 \ + simple_cyclic2.smt2 \ + DRAGON_11_e1_2450.ec.minimized.smt2 \ + FIREFLY_3_e2_2236_e7_3681.ec.core.smt2 \ + speed2_e8_449_e8_517.ec.smt2 \ + stalmark_e7_27_e7_31.ec.smt2 + + +EXTRA_DIST = $(TESTS) \ + DRAGON_11_e1_2450.ec.minimized.smt2.expect \ + FIREFLY_3_e2_2236_e7_3681.ec.core.smt2.expect \ + speed2_e8_449_e8_517.ec.smt2.expect \ + stalmark_e7_27_e7_31.ec.smt2.expect + +# synonyms for "check" in this directory +.PHONY: regress regress1 test +regress regress1 test: check + +# do nothing in this subdir +.PHONY: regress0 regress2 regress3 regress4 +regress0 regress2 regress3 regress4: diff --git a/test/regress/regress1/uflia/microwave21.ec.minimized.smt2 b/test/regress/regress1/uflia/microwave21.ec.minimized.smt2 new file mode 100644 index 000000000..b37db9a1e --- /dev/null +++ b/test/regress/regress1/uflia/microwave21.ec.minimized.smt2 @@ -0,0 +1,444 @@ +; initialize_defs +; PROPERTY DEFGEN +(set-logic QF_UFNIA) +(set-info :status unsat) +(declare-fun _base () Int) +(declare-fun _n () Int) +(assert (>= _n 0)) + +; maxdepth = 1 +(declare-fun ___z2z___ (Int) Bool) + ; KP_START ; INPUT,STATE(1,)/102 +(declare-fun ___z3z___ (Int) Bool) + ; KP_CLEAR ; INPUT,STATE(1,)/103 +(declare-fun ___z4z___ (Int) Bool) + ; KP_0 ; INPUT,STATE(1,)/104 +(declare-fun ___z5z___ (Int) Bool) + ; KP_1 ; INPUT,STATE(1,)/105 +(declare-fun ___z6z___ (Int) Bool) + ; KP_2 ; INPUT,STATE(1,)/106 +(declare-fun ___z7z___ (Int) Bool) + ; KP_3 ; INPUT,STATE(1,)/107 +(declare-fun ___z8z___ (Int) Bool) + ; KP_4 ; INPUT,STATE(1,)/108 +(declare-fun ___z9z___ (Int) Bool) + ; KP_5 ; INPUT,STATE(1,)/109 +(declare-fun ___z10z___ (Int) Bool) + ; KP_6 ; INPUT,STATE(1,)/110 +(declare-fun ___z11z___ (Int) Bool) + ; KP_7 ; INPUT,STATE(1,)/111 +(declare-fun ___z12z___ (Int) Bool) + ; KP_8 ; INPUT,STATE(1,)/112 +(declare-fun ___z13z___ (Int) Bool) + ; KP_9 ; INPUT,STATE(1,)/113 +(declare-fun ___z14z___ (Int) Bool) + ; DOOR_CLOSED ; INPUT/114 +(declare-fun ___z15z___ (Int) Bool) + ; OK ; OUTPUT/115 +(declare-fun ___z19z___ (Int) Bool) + ; V20_START_PRESSED ; LOCAL/119 +(declare-fun ___z20z___ (Int) Bool) + ; V21_CLEAR_PRESSED ; LOCAL/120 +(declare-fun ___z21z___ (Int) Int) + ; V25_STEPS_TO_COOK ; LOCAL,STATE(1,)/121 +(declare-fun ___z22z___ (Int) Bool) + ; V26_rlt_condact_resetmicrowave_microwave_KEYPAD_PROCESSING_rlt_clock ; LOCAL,STATE(1,)/122 +(declare-fun ___z23z___ (Int) Bool) + ; V37_rlt_condact_resetmicrowave_microwave_KEYPAD_PROCESSING_rlt_init_step ; LOCAL,STATE(1,)/123 +(declare-fun ___z24z___ (Int) Int) + ; V38_microwave_microwave_KEYPAD_PROCESSING_DISPLAY_LEFT_DIGIT_DIGIT_TO_DISPLAY ; LOCAL,STATE(1,)/124 +(declare-fun ___z25z___ (Int) Int) + ; V39_microwave_microwave_KEYPAD_PROCESSING_DISPLAY_MIDDLE_DIGIT_DIGIT_TO_DISPLAY ; LOCAL,STATE(1,)/125 +(declare-fun ___z26z___ (Int) Int) + ; V40_microwave_microwave_KEYPAD_PROCESSING_DISPLAY_RIGHT_DIGIT_DIGIT_TO_DISPLAY ; LOCAL,STATE(1,)/126 +(declare-fun ___z33z___ (Int) Int) + ; V47_chart_microwave_mode_logic_start ; LOCAL/133 +(declare-fun ___z34z___ (Int) Int) + ; V48_chart_microwave_mode_logic_clear_off ; LOCAL/134 +(declare-fun ___z35z___ (Int) Int) + ; V49_chart_microwave_mode_logic_door_closed ; LOCAL/135 +(declare-fun ___z36z___ (Int) Bool) + ; V51_rlt_eval_microwave_mode_logic_ON_rlt_fired_1 ; LOCAL/136 +(declare-fun ___z37z___ (Int) Int) + ; V52_rlt_eval_microwave_mode_logic_ON_rlt_state_1_states___root ; LOCAL/137 +(declare-fun ___z38z___ (Int) Int) + ; V53_rlt_eval_microwave_mode_logic_ON_rlt_state_2_states___root ; LOCAL/138 +(declare-fun ___z39z___ (Int) Bool) + ; V54_rlt_eval_microwave_mode_logic_ON_rlt_fired_2 ; LOCAL/139 +(declare-fun ___z40z___ (Int) Bool) + ; V55_rlt_eval_microwave_mode_logic_ON_rlt_complete_1 ; LOCAL/140 +(declare-fun ___z41z___ (Int) Int) + ; V56_rlt_eval_microwave_mode_logic_ON_rlt_state_3_states___root ; LOCAL/141 +(declare-fun ___z42z___ (Int) Int) + ; V57_rlt_eval_microwave_mode_logic_ON_rlt_state_3_outports_mode ; LOCAL/142 +(declare-fun ___z43z___ (Int) Int) + ; V58_rlt_eval_microwave_mode_logic_ON_rlt_state_4_states___root ; LOCAL/143 +(declare-fun ___z44z___ (Int) Int) + ; V59_rlt_eval_microwave_mode_logic_ON_rlt_state_4_outports_mode ; LOCAL/144 +(declare-fun ___z45z___ (Int) Bool) + ; V60_rlt_eval_microwave_mode_logic_ON_rlt_fired_4 ; LOCAL/145 +(declare-fun ___z46z___ (Int) Bool) + ; V61_rlt_eval_microwave_mode_logic_ON_rlt_complete_2 ; LOCAL/146 +(declare-fun ___z47z___ (Int) Int) + ; V62_rlt_eval_microwave_mode_logic_ON_rlt_state_6_states___root ; LOCAL/147 +(declare-fun ___z48z___ (Int) Int) + ; V63_rlt_eval_microwave_mode_logic_ON_rlt_state_6_outports_steps_remaining ; LOCAL/148 +(declare-fun ___z49z___ (Int) Int) + ; V64_rlt_eval_microwave_mode_logic_ON_rlt_state_7_states___root ; LOCAL/149 +(declare-fun ___z50z___ (Int) Bool) + ; V65_rlt_eval_microwave_mode_logic_ON_rlt_fired_5 ; LOCAL/150 +(declare-fun ___z51z___ (Int) Int) + ; V66_rlt_eval_microwave_mode_logic_ON_rlt_state_8_outports_mode ; LOCAL/151 +(declare-fun ___z52z___ (Int) Int) + ; V67_rlt_eval_microwave_mode_logic_ON_rlt_state_9_states___root ; LOCAL/152 +(declare-fun ___z53z___ (Int) Int) + ; V68_rlt_eval_microwave_mode_logic_ON_rlt_state_10_states___root ; LOCAL/153 +(declare-fun ___z54z___ (Int) Bool) + ; V69_rlt_eval_microwave_mode_logic_ON_rlt_fired_6 ; LOCAL/154 +(declare-fun ___z55z___ (Int) Int) + ; V70_rlt_eval_microwave_mode_logic_ON_rlt_state_11_states___root ; LOCAL/155 +(declare-fun ___z56z___ (Int) Int) + ; V71_rlt_eval_microwave_mode_logic_ON_rlt_state_11_outports_mode ; LOCAL/156 +(declare-fun ___z57z___ (Int) Int) + ; V72_rlt_enter_microwave_mode_logic_ON_rlt_state_1_states___root ; LOCAL/157 +(declare-fun ___z58z___ (Int) Bool) + ; V73_rlt_enter_microwave_mode_logic_ON_rlt_fired_0 ; LOCAL/158 +(declare-fun ___z59z___ (Int) Bool) + ; V74_rlt_enter_microwave_mode_logic_ON_rlt_fired_1 ; LOCAL/159 +(declare-fun ___z60z___ (Int) Int) + ; V75_rlt_enter_microwave_mode_logic_ON_rlt_state_2_states___root ; LOCAL/160 +(declare-fun ___z61z___ (Int) Int) + ; V76_rlt_enter_microwave_mode_logic_ON_rlt_state_2_outports_mode ; LOCAL/161 +(declare-fun ___z62z___ (Int) Bool) + ; V77_rlt_enter_microwave_mode_logic_ON_rlt_fired_2 ; LOCAL/162 +(declare-fun ___z63z___ (Int) Int) + ; V78_rlt_enter_microwave_mode_logic_ON_rlt_state_4_states___root ; LOCAL/163 +(declare-fun ___z64z___ (Int) Bool) + ; V79_rlt_eval_microwave_mode_logic_rlt_fired_0 ; LOCAL/164 +(declare-fun ___z65z___ (Int) Int) + ; V80_rlt_eval_microwave_mode_logic_rlt_state_1_outports_steps_remaining ; LOCAL/165 +(declare-fun ___z66z___ (Int) Bool) + ; V81_rlt_eval_microwave_mode_logic_rlt_fired_1 ; LOCAL/166 +(declare-fun ___z67z___ (Int) Int) + ; V82_rlt_eval_microwave_mode_logic_rlt_state_2_states___root ; LOCAL/167 +(declare-fun ___z68z___ (Int) Int) + ; V83_rlt_eval_microwave_mode_logic_rlt_state_3_states___root ; LOCAL/168 +(declare-fun ___z69z___ (Int) Int) + ; V84_rlt_eval_microwave_mode_logic_rlt_state_3_outports_mode ; LOCAL/169 +(declare-fun ___z70z___ (Int) Int) + ; V85_rlt_enter_microwave_mode_logic_rlt_state_2_states___root ; LOCAL/170 +(declare-fun ___z71z___ (Int) Bool) + ; V86_chart_microwave_mode_logic_rlt_evtInitStep ; LOCAL,STATE(1,)/171 +(declare-fun ___z72z___ (Int) Int) + ; V87_chart_microwave_mode_logic_begin_state_states___root ; LOCAL/172 +(declare-fun ___z73z___ (Int) Int) + ; V88_chart_microwave_mode_logic_begin_state_outports_mode ; LOCAL/173 +(declare-fun ___z74z___ (Int) Int) + ; V89_chart_microwave_mode_logic_begin_state_outports_steps_remaining ; LOCAL/174 +(declare-fun ___z75z___ (Int) Int) + ; V90_chart_microwave_mode_logic_final_state_states___root ; LOCAL,STATE(1,)/175 +(declare-fun ___z76z___ (Int) Int) + ; V92_chart_microwave_mode_logic_steps_remaining ; LOCAL,STATE(1,)/176 +(declare-fun ___z77z___ (Int) Int) + ; V93_microwave_microwave_TIME_ON_DISPLAY_SECONDS_TO_MINUTES__QUOTIENT ; LOCAL/177 +(declare-fun ___z80z___ (Int) Int) + ; V96_microwave_microwave_mode_logic_mode ; LOCAL,STATE(1,)/180 + + +; Generic definitions: +(define-fun DEF__172 ((_M Int)) Bool(= (___z72z___ _M) (ite (= _M _base) 0 (___z75z___ (- _M 1))))) +(define-fun DEF__173 ((_M Int)) Bool(= (___z73z___ _M) (ite (= _M _base) 0 (___z80z___ (- _M 1))))) +(define-fun DEF__174 ((_M Int)) Bool(= (___z74z___ _M) (ite (= _M _base) 0 (___z76z___ (- _M 1))))) +(define-fun DEF__175 ((_M Int)) Bool(= (___z75z___ _M) (ite (= (___z71z___ _M) true) (___z70z___ _M) (ite (= (and (not (___z66z___ _M)) (and (>= (___z68z___ _M) 1) (<= (___z68z___ _M) 3))) true) (ite (= (___z54z___ _M) true) (ite (= (not (= (___z55z___ _M) 3)) true) 3 (___z55z___ _M)) (___z55z___ _M)) (___z68z___ _M))))) +(define-fun DEF__133 ((_M Int)) Bool(= (___z33z___ _M) (ite (= (= (___z19z___ _M) false) true) 0 1))) +(define-fun DEF__176 ((_M Int)) Bool(= (___z76z___ _M) (ite (= (___z71z___ _M) true) (___z74z___ _M) (ite (= (and (not (___z66z___ _M)) (and (>= (___z68z___ _M) 1) (<= (___z68z___ _M) 3))) true) (ite (= (___z50z___ _M) true) (- (___z48z___ _M) 1) (___z48z___ _M)) (___z65z___ _M))))) +(define-fun DEF__134 ((_M Int)) Bool(= (___z34z___ _M) (ite (= (= (___z20z___ _M) false) true) 0 1))) +(define-fun DEF__177 ((_M Int)) Bool(= (___z77z___ _M) (div (div (___z76z___ _M) 1) 60))) +(define-fun DEF__135 ((_M Int)) Bool(= (___z35z___ _M) (ite (= (= (___z14z___ _M) false) true) 0 1))) +(define-fun DEF__136 ((_M Int)) Bool(= (___z36z___ _M) (and (and (= (___z68z___ _M) 2) (<= (___z65z___ _M) 0)) (= (___z68z___ _M) 2)))) +(define-fun DEF__180 ((_M Int)) Bool(= (___z80z___ _M) (ite (= (___z71z___ _M) true) (ite (= (not (= (___z72z___ _M) 4)) true) 1 (___z73z___ _M)) (ite (= (and (not (___z66z___ _M)) (and (>= (___z68z___ _M) 1) (<= (___z68z___ _M) 3))) true) (ite (= (___z54z___ _M) true) (ite (= (not (= (___z55z___ _M) 3)) true) 3 (___z56z___ _M)) (___z56z___ _M)) (___z69z___ _M))))) +(define-fun DEF__137 ((_M Int)) Bool(= (___z37z___ _M) (ite (= (___z36z___ _M) true) (ite (= (and (>= (___z68z___ _M) 1) (<= (___z68z___ _M) 3)) true) 0 (___z68z___ _M)) (___z68z___ _M)))) +(define-fun DEF__138 ((_M Int)) Bool(= (___z38z___ _M) (ite (= (___z36z___ _M) true) (ite (= (not (= (___z37z___ _M) 4)) true) 4 (___z37z___ _M)) (___z37z___ _M)))) +(define-fun DEF__139 ((_M Int)) Bool(= (___z39z___ _M) (and (= (___z38z___ _M) 3) (and (and (ite (= (not (= (___z33z___ _M) 0)) true) true false) (ite (= (not (= (___z35z___ _M) 0)) true) true false)) (not (___z36z___ _M)))))) +(define-fun DEF__140 ((_M Int)) Bool(= (___z40z___ _M) (or (___z39z___ _M) (___z36z___ _M)))) +(define-fun DEF__141 ((_M Int)) Bool(= (___z41z___ _M) (ite (= (___z39z___ _M) true) (ite (= (___z38z___ _M) 3) 1 (___z38z___ _M)) (___z38z___ _M)))) +(define-fun DEF__142 ((_M Int)) Bool(= (___z42z___ _M) (ite (= (___z36z___ _M) true) (ite (= (not (= (___z37z___ _M) 4)) true) 1 (___z69z___ _M)) (___z69z___ _M)))) +(define-fun DEF__143 ((_M Int)) Bool(= (___z43z___ _M) (ite (= (___z39z___ _M) true) (ite (= (not (= (___z41z___ _M) 2)) true) 2 (___z41z___ _M)) (___z41z___ _M)))) +(define-fun DEF__144 ((_M Int)) Bool(= (___z44z___ _M) (ite (= (___z39z___ _M) true) (ite (= (not (= (___z41z___ _M) 2)) true) 2 (___z42z___ _M)) (___z42z___ _M)))) +(define-fun DEF__145 ((_M Int)) Bool(= (___z45z___ _M) (and (and (= (___z43z___ _M) 3) (and (ite (= (not (= (___z34z___ _M) 0)) true) true false) (not (___z40z___ _M)))) (and (= (___z43z___ _M) 3) (not (___z40z___ _M)))))) +(define-fun DEF__146 ((_M Int)) Bool(= (___z46z___ _M) (or (___z45z___ _M) (___z40z___ _M)))) +(define-fun DEF__147 ((_M Int)) Bool(= (___z47z___ _M) (ite (= (___z45z___ _M) true) (ite (= (and (>= (___z43z___ _M) 1) (<= (___z43z___ _M) 3)) true) 0 (___z43z___ _M)) (___z43z___ _M)))) +(define-fun DEF__148 ((_M Int)) Bool(= (___z48z___ _M) (ite (= (___z45z___ _M) true) 0 (___z65z___ _M)))) +(define-fun DEF__149 ((_M Int)) Bool(= (___z49z___ _M) (ite (= (___z45z___ _M) true) (ite (= (not (= (___z47z___ _M) 4)) true) 4 (___z47z___ _M)) (___z47z___ _M)))) +(define-fun DEF__150 ((_M Int)) Bool(= (___z50z___ _M) (and (= (___z49z___ _M) 2) (and (> (___z48z___ _M) 0) (not (___z46z___ _M)))))) +(define-fun DEF__151 ((_M Int)) Bool(= (___z51z___ _M) (ite (= (___z45z___ _M) true) (ite (= (not (= (___z47z___ _M) 4)) true) 1 (___z44z___ _M)) (___z44z___ _M)))) +(define-fun DEF__152 ((_M Int)) Bool(= (___z52z___ _M) (ite (= (___z50z___ _M) true) (ite (= (___z49z___ _M) 2) 1 (___z49z___ _M)) (___z49z___ _M)))) +(define-fun DEF__153 ((_M Int)) Bool(= (___z53z___ _M) (ite (= (___z50z___ _M) true) (ite (= (not (= (___z52z___ _M) 2)) true) 2 (___z52z___ _M)) (___z52z___ _M)))) +(define-fun DEF__154 ((_M Int)) Bool(= (___z54z___ _M) (and (= (___z53z___ _M) 2) (and (or (ite (= (not (= (___z34z___ _M) 0)) true) true false) (not (ite (= (not (= (___z35z___ _M) 0)) true) true false))) (not (or (___z50z___ _M) (___z46z___ _M))))))) +(define-fun DEF__155 ((_M Int)) Bool(= (___z55z___ _M) (ite (= (___z54z___ _M) true) (ite (= (___z53z___ _M) 2) 1 (___z53z___ _M)) (___z53z___ _M)))) +(define-fun DEF__156 ((_M Int)) Bool(= (___z56z___ _M) (ite (= (___z50z___ _M) true) (ite (= (not (= (___z52z___ _M) 2)) true) 2 (___z51z___ _M)) (___z51z___ _M)))) +(define-fun DEF__157 ((_M Int)) Bool(= (___z57z___ _M) (ite (= (not (and (>= (___z67z___ _M) 1) (<= (___z67z___ _M) 3))) true) 1 (___z67z___ _M)))) +(define-fun DEF__115 ((_M Int)) Bool(= (___z15z___ _M) (ite (= _M _base) (or (not (and (___z22z___ _M) (not (___z3z___ _M)))) (or (not (or (or (or (or (or (or (or (or (or (___z5z___ _M) (___z6z___ _M)) (___z7z___ _M)) (___z8z___ _M)) (___z9z___ _M)) (___z10z___ _M)) (___z11z___ _M)) (___z12z___ _M)) (___z13z___ _M)) (___z4z___ _M))) (= (___z77z___ _M) (div (div (___z21z___ _M) 1) 60)))) (or (not (and (___z22z___ _M) (not (___z3z___ _M)))) (or (not (or (or (or (or (or (or (or (or (or (and (___z5z___ _M) (not (___z5z___ (- _M 1)))) (and (___z6z___ _M) (not (___z6z___ (- _M 1))))) (and (___z7z___ _M) (not (___z7z___ (- _M 1))))) (and (___z8z___ _M) (not (___z8z___ (- _M 1))))) (and (___z9z___ _M) (not (___z9z___ (- _M 1))))) (and (___z10z___ _M) (not (___z10z___ (- _M 1))))) (and (___z11z___ _M) (not (___z11z___ (- _M 1))))) (and (___z12z___ _M) (not (___z12z___ (- _M 1))))) (and (___z13z___ _M) (not (___z13z___ (- _M 1))))) (and (___z4z___ _M) (not (___z4z___ (- _M 1)))))) (= (___z77z___ _M) (div (div (___z21z___ _M) 1) 60))))))) +(define-fun DEF__158 ((_M Int)) Bool(= (___z58z___ _M) (and (not (and (>= (___z67z___ _M) 1) (<= (___z67z___ _M) 3))) (and (>= (___z57z___ _M) 1) (<= (___z57z___ _M) 3))))) +(define-fun DEF__159 ((_M Int)) Bool(= (___z59z___ _M) (and (___z58z___ _M) (and (and (>= (___z57z___ _M) 1) (<= (___z57z___ _M) 3)) (ite (= (not (= (___z35z___ _M) 0)) true) true false))))) +(define-fun DEF__160 ((_M Int)) Bool(= (___z60z___ _M) (ite (= (___z59z___ _M) true) (ite (= (not (= (___z57z___ _M) 2)) true) 2 (___z57z___ _M)) (___z57z___ _M)))) +(define-fun DEF__161 ((_M Int)) Bool(= (___z61z___ _M) (ite (= (___z59z___ _M) true) (ite (= (not (= (___z57z___ _M) 2)) true) 2 (___z73z___ _M)) (___z73z___ _M)))) +(define-fun DEF__119 ((_M Int)) Bool(= (___z19z___ _M) (ite (= _M _base) (___z2z___ _M) (and (___z2z___ _M) (not (___z2z___ (- _M 1))))))) +(define-fun DEF__162 ((_M Int)) Bool(= (___z62z___ _M) (and (___z58z___ _M) (and (and (>= (___z60z___ _M) 1) (<= (___z60z___ _M) 3)) (not (___z59z___ _M)))))) +(define-fun DEF__120 ((_M Int)) Bool(= (___z20z___ _M) (ite (= _M _base) (___z3z___ _M) (and (___z3z___ _M) (not (___z3z___ (- _M 1))))))) +(define-fun DEF__163 ((_M Int)) Bool(= (___z63z___ _M) (ite (= (___z62z___ _M) true) (ite (= (not (= (___z60z___ _M) 3)) true) 3 (___z60z___ _M)) (___z60z___ _M)))) +(define-fun DEF__121 ((_M Int)) Bool(= (___z21z___ _M) (ite (= _M _base) (ite (= (and (___z23z___ _M) (not (___z22z___ _M))) true) 0 (* (+ (+ (* (___z26z___ _M) 1) (* (___z25z___ _M) 10)) (* (___z24z___ _M) 60)) 1)) (ite (= (and (___z23z___ _M) (not (___z22z___ _M))) true) 0 (ite (= (___z22z___ _M) true) (* (+ (+ (* (___z26z___ _M) 1) (* (___z25z___ _M) 10)) (* (___z24z___ _M) 60)) 1) (___z21z___ (- _M 1))))))) +(define-fun DEF__164 ((_M Int)) Bool(= (___z64z___ _M) (= (___z72z___ _M) 4))) +(define-fun DEF__122 ((_M Int)) Bool(= (___z22z___ _M) (ite (= _M _base) true (ite (= 1 (___z80z___ (- _M 1))) true false)))) +(define-fun DEF__165 ((_M Int)) Bool(= (___z65z___ _M) (ite (= (___z64z___ _M) true) (___z21z___ _M) (___z74z___ _M)))) +(define-fun DEF__123 ((_M Int)) Bool(= (___z23z___ _M) (ite (= _M _base) true (ite (= (not (___z22z___ _M)) true) true (ite (= (___z22z___ (- _M 1)) true) false (___z23z___ (- _M 1))))))) +(define-fun DEF__166 ((_M Int)) Bool(= (___z66z___ _M) (and (___z64z___ _M) (and (= (___z72z___ _M) 4) (and (ite (= (not (= (___z33z___ _M) 0)) true) true false) (ite (= (not (= (ite (= (= (> (___z21z___ _M) 0) false) true) 0 1) 0)) true) true false)))))) +(define-fun DEF__124 ((_M Int)) Bool(= (___z24z___ _M) (ite (= _M _base) 0 (ite (= (___z22z___ _M) true) (ite (= (___z23z___ _M) true) 0 (ite (= (___z3z___ _M) true) 0 (ite (= (ite (<= (ite (= (and (___z4z___ _M) (not (___z4z___ (- _M 1)))) true) 0 (ite (= (and (___z5z___ _M) (not (___z5z___ (- _M 1)))) true) 1 (ite (= (and (___z6z___ _M) (not (___z6z___ (- _M 1)))) true) 2 (ite (= (and (___z7z___ _M) (not (___z7z___ (- _M 1)))) true) 3 (ite (= (and (___z8z___ _M) (not (___z8z___ (- _M 1)))) true) 4 (ite (= (and (___z9z___ _M) (not (___z9z___ (- _M 1)))) true) 5 (ite (= (and (___z10z___ _M) (not (___z10z___ (- _M 1)))) true) 6 (ite (= (and (___z11z___ _M) (not (___z11z___ (- _M 1)))) true) 7 (ite (= (and (___z12z___ _M) (not (___z12z___ (- _M 1)))) true) 8 (ite (= (and (___z13z___ _M) (not (___z13z___ (- _M 1)))) true) 9 10)))))))))) 9) true false) true) (___z25z___ (- _M 1)) (___z24z___ (- _M 1))))) (___z24z___ (- _M 1)))))) +(define-fun DEF__167 ((_M Int)) Bool(= (___z67z___ _M) (ite (= (___z66z___ _M) true) (ite (= (___z72z___ _M) 4) 0 (___z72z___ _M)) (___z72z___ _M)))) +(define-fun DEF__125 ((_M Int)) Bool(= (___z25z___ _M) (ite (= _M _base) 0 (ite (= (___z22z___ _M) true) (ite (= (___z23z___ _M) true) 0 (ite (= (___z3z___ _M) true) 0 (ite (= (ite (<= (ite (= (and (___z4z___ _M) (not (___z4z___ (- _M 1)))) true) 0 (ite (= (and (___z5z___ _M) (not (___z5z___ (- _M 1)))) true) 1 (ite (= (and (___z6z___ _M) (not (___z6z___ (- _M 1)))) true) 2 (ite (= (and (___z7z___ _M) (not (___z7z___ (- _M 1)))) true) 3 (ite (= (and (___z8z___ _M) (not (___z8z___ (- _M 1)))) true) 4 (ite (= (and (___z9z___ _M) (not (___z9z___ (- _M 1)))) true) 5 (ite (= (and (___z10z___ _M) (not (___z10z___ (- _M 1)))) true) 6 (ite (= (and (___z11z___ _M) (not (___z11z___ (- _M 1)))) true) 7 (ite (= (and (___z12z___ _M) (not (___z12z___ (- _M 1)))) true) 8 (ite (= (and (___z13z___ _M) (not (___z13z___ (- _M 1)))) true) 9 10)))))))))) 9) true false) true) (___z26z___ (- _M 1)) (___z25z___ (- _M 1))))) (___z25z___ (- _M 1)))))) +(define-fun DEF__168 ((_M Int)) Bool(= (___z68z___ _M) (ite (= (___z66z___ _M) true) (___z63z___ _M) (___z67z___ _M)))) +(define-fun DEF__126 ((_M Int)) Bool(= (___z26z___ _M) (ite (= _M _base) (ite (= (___z3z___ _M) true) 0 (ite (= (ite (<= (ite (= (___z4z___ _M) true) 0 (ite (= (___z5z___ _M) true) 1 (ite (= (___z6z___ _M) true) 2 (ite (= (___z7z___ _M) true) 3 (ite (= (___z8z___ _M) true) 4 (ite (= (___z9z___ _M) true) 5 (ite (= (___z10z___ _M) true) 6 (ite (= (___z11z___ _M) true) 7 (ite (= (___z12z___ _M) true) 8 (ite (= (___z13z___ _M) true) 9 10)))))))))) 9) true false) true) (ite (= (___z4z___ _M) true) 0 (ite (= (___z5z___ _M) true) 1 (ite (= (___z6z___ _M) true) 2 (ite (= (___z7z___ _M) true) 3 (ite (= (___z8z___ _M) true) 4 (ite (= (___z9z___ _M) true) 5 (ite (= (___z10z___ _M) true) 6 (ite (= (___z11z___ _M) true) 7 (ite (= (___z12z___ _M) true) 8 (ite (= (___z13z___ _M) true) 9 10)))))))))) 0)) (ite (= (___z22z___ _M) true) (ite (= (___z23z___ _M) true) (ite (= (___z3z___ _M) true) 0 (ite (= (ite (<= (ite (= (___z4z___ _M) true) 0 (ite (= (___z5z___ _M) true) 1 (ite (= (___z6z___ _M) true) 2 (ite (= (___z7z___ _M) true) 3 (ite (= (___z8z___ _M) true) 4 (ite (= (___z9z___ _M) true) 5 (ite (= (___z10z___ _M) true) 6 (ite (= (___z11z___ _M) true) 7 (ite (= (___z12z___ _M) true) 8 (ite (= (___z13z___ _M) true) 9 10)))))))))) 9) true false) true) (ite (= (___z4z___ _M) true) 0 (ite (= (___z5z___ _M) true) 1 (ite (= (___z6z___ _M) true) 2 (ite (= (___z7z___ _M) true) 3 (ite (= (___z8z___ _M) true) 4 (ite (= (___z9z___ _M) true) 5 (ite (= (___z10z___ _M) true) 6 (ite (= (___z11z___ _M) true) 7 (ite (= (___z12z___ _M) true) 8 (ite (= (___z13z___ _M) true) 9 10)))))))))) 0)) (ite (= (___z3z___ _M) true) 0 (ite (= (ite (<= (ite (= (and (___z4z___ _M) (not (___z4z___ (- _M 1)))) true) 0 (ite (= (and (___z5z___ _M) (not (___z5z___ (- _M 1)))) true) 1 (ite (= (and (___z6z___ _M) (not (___z6z___ (- _M 1)))) true) 2 (ite (= (and (___z7z___ _M) (not (___z7z___ (- _M 1)))) true) 3 (ite (= (and (___z8z___ _M) (not (___z8z___ (- _M 1)))) true) 4 (ite (= (and (___z9z___ _M) (not (___z9z___ (- _M 1)))) true) 5 (ite (= (and (___z10z___ _M) (not (___z10z___ (- _M 1)))) true) 6 (ite (= (and (___z11z___ _M) (not (___z11z___ (- _M 1)))) true) 7 (ite (= (and (___z12z___ _M) (not (___z12z___ (- _M 1)))) true) 8 (ite (= (and (___z13z___ _M) (not (___z13z___ (- _M 1)))) true) 9 10)))))))))) 9) true false) true) (ite (= (and (___z4z___ _M) (not (___z4z___ (- _M 1)))) true) 0 (ite (= (and (___z5z___ _M) (not (___z5z___ (- _M 1)))) true) 1 (ite (= (and (___z6z___ _M) (not (___z6z___ (- _M 1)))) true) 2 (ite (= (and (___z7z___ _M) (not (___z7z___ (- _M 1)))) true) 3 (ite (= (and (___z8z___ _M) (not (___z8z___ (- _M 1)))) true) 4 (ite (= (and (___z9z___ _M) (not (___z9z___ (- _M 1)))) true) 5 (ite (= (and (___z10z___ _M) (not (___z10z___ (- _M 1)))) true) 6 (ite (= (and (___z11z___ _M) (not (___z11z___ (- _M 1)))) true) 7 (ite (= (and (___z12z___ _M) (not (___z12z___ (- _M 1)))) true) 8 (ite (= (and (___z13z___ _M) (not (___z13z___ (- _M 1)))) true) 9 10)))))))))) (___z26z___ (- _M 1))))) (___z26z___ (- _M 1)))))) +(define-fun DEF__169 ((_M Int)) Bool(= (___z69z___ _M) (ite (= (___z66z___ _M) true) (ite (= (___z62z___ _M) true) (ite (= (not (= (___z60z___ _M) 3)) true) 3 (___z61z___ _M)) (___z61z___ _M)) (___z73z___ _M)))) +(define-fun DEF__170 ((_M Int)) Bool(= (___z70z___ _M) (ite (= (not (= (___z72z___ _M) 4)) true) 4 (___z72z___ _M)))) +(define-fun DEF__171 ((_M Int)) Bool(= (___z71z___ _M) (ite (= _M _base) true (ite (= true true) false (___z71z___ (- _M 1)))))) +; Transition: +(define-fun trans ((_M Int)) Bool (and (DEF__171 _M) (DEF__170 _M) (DEF__169 _M) (DEF__126 _M) (DEF__168 _M) (DEF__125 _M) (DEF__167 _M) (DEF__124 _M) (DEF__166 _M) (DEF__123 _M) (DEF__165 _M) (DEF__122 _M) (DEF__164 _M) (DEF__121 _M) (DEF__163 _M) (DEF__120 _M) (DEF__162 _M) (DEF__119 _M) (DEF__161 _M) (DEF__160 _M) (DEF__159 _M) (DEF__158 _M) (DEF__115 _M) (DEF__157 _M) (DEF__156 _M) (DEF__155 _M) (DEF__154 _M) (DEF__153 _M) (DEF__152 _M) (DEF__151 _M) (DEF__150 _M) (DEF__149 _M) (DEF__148 _M) (DEF__147 _M) (DEF__146 _M) (DEF__145 _M) (DEF__144 _M) (DEF__143 _M) (DEF__142 _M) (DEF__141 _M) (DEF__140 _M) (DEF__139 _M) (DEF__138 _M) (DEF__137 _M) (DEF__180 _M) (DEF__136 _M) (DEF__135 _M) (DEF__177 _M) (DEF__134 _M) (DEF__176 _M) (DEF__133 _M) (DEF__175 _M) (DEF__174 _M) (DEF__173 _M) (DEF__172 _M) )) + +(define-fun P ((_M Int)) Bool(= (___z15z___ _M) true)) + + + +; BASE DONE + +; Begin induction: +; print_initialization +; def_assert_both1 +; def_assert_both +(assert (DEF__172 0)) +; print_checker_assertion +(assert (DEF__173 0)) +; print_checker_assertion +(assert (DEF__174 0)) +; print_checker_assertion +(assert (DEF__175 0)) +; print_checker_assertion +(assert (DEF__133 0)) +; print_checker_assertion +(assert (DEF__176 0)) +; print_checker_assertion +(assert (DEF__134 0)) +; print_checker_assertion +(assert (DEF__177 0)) +; print_checker_assertion +(assert (DEF__135 0)) +; print_checker_assertion +(assert (DEF__136 0)) +; print_checker_assertion +(assert (DEF__180 0)) +; print_checker_assertion +(assert (DEF__137 0)) +; print_checker_assertion +(assert (DEF__138 0)) +; print_checker_assertion +(assert (DEF__139 0)) +; print_checker_assertion +(assert (DEF__140 0)) +; print_checker_assertion +(assert (DEF__141 0)) +; print_checker_assertion +(assert (DEF__142 0)) +; print_checker_assertion +(assert (DEF__143 0)) +; print_checker_assertion +(assert (DEF__144 0)) +; print_checker_assertion +(assert (DEF__145 0)) +; print_checker_assertion +(assert (DEF__146 0)) +; print_checker_assertion +(assert (DEF__147 0)) +; print_checker_assertion +(assert (DEF__148 0)) +; print_checker_assertion +(assert (DEF__149 0)) +; print_checker_assertion +(assert (DEF__150 0)) +; print_checker_assertion +(assert (DEF__151 0)) +; print_checker_assertion +(assert (DEF__152 0)) +; print_checker_assertion +(assert (DEF__153 0)) +; print_checker_assertion +(assert (DEF__154 0)) +; print_checker_assertion +(assert (DEF__155 0)) +; print_checker_assertion +(assert (DEF__156 0)) +; print_checker_assertion +(assert (DEF__157 0)) +; print_checker_assertion +(assert (DEF__115 0)) +; print_checker_assertion +(assert (DEF__158 0)) +; print_checker_assertion +(assert (DEF__159 0)) +; print_checker_assertion +(assert (DEF__160 0)) +; print_checker_assertion +(assert (DEF__161 0)) +; print_checker_assertion +(assert (DEF__119 0)) +; print_checker_assertion +(assert (DEF__162 0)) +; print_checker_assertion +(assert (DEF__120 0)) +; print_checker_assertion +(assert (DEF__163 0)) +; print_checker_assertion +(assert (DEF__121 0)) +; print_checker_assertion +(assert (DEF__164 0)) +; print_checker_assertion +(assert (DEF__122 0)) +; print_checker_assertion +(assert (DEF__165 0)) +; print_checker_assertion +(assert (DEF__123 0)) +; print_checker_assertion +(assert (DEF__166 0)) +; print_checker_assertion +(assert (DEF__124 0)) +; print_checker_assertion +(assert (DEF__167 0)) +; print_checker_assertion +(assert (DEF__125 0)) +; print_checker_assertion +(assert (DEF__168 0)) +; print_checker_assertion +(assert (DEF__126 0)) +; print_checker_assertion +(assert (DEF__169 0)) +; print_checker_assertion +(assert (DEF__170 0)) +; print_checker_assertion +(assert (DEF__171 0)) +; print_checker_assertion +; def_assert_both1 +; def_assert_both +(assert (DEF__172 (- 0 1))) +; print_checker_assertion +(assert (DEF__173 (- 0 1))) +; print_checker_assertion +(assert (DEF__174 (- 0 1))) +; print_checker_assertion +(assert (DEF__175 (- 0 1))) +; print_checker_assertion +(assert (DEF__133 (- 0 1))) +; print_checker_assertion +(assert (DEF__176 (- 0 1))) +; print_checker_assertion +(assert (DEF__134 (- 0 1))) +; print_checker_assertion +(assert (DEF__177 (- 0 1))) +; print_checker_assertion +(assert (DEF__135 (- 0 1))) +; print_checker_assertion +(assert (DEF__136 (- 0 1))) +; print_checker_assertion +(assert (DEF__180 (- 0 1))) +; print_checker_assertion +(assert (DEF__137 (- 0 1))) +; print_checker_assertion +(assert (DEF__138 (- 0 1))) +; print_checker_assertion +(assert (DEF__139 (- 0 1))) +; print_checker_assertion +(assert (DEF__140 (- 0 1))) +; print_checker_assertion +(assert (DEF__141 (- 0 1))) +; print_checker_assertion +(assert (DEF__142 (- 0 1))) +; print_checker_assertion +(assert (DEF__143 (- 0 1))) +; print_checker_assertion +(assert (DEF__144 (- 0 1))) +; print_checker_assertion +(assert (DEF__145 (- 0 1))) +; print_checker_assertion +(assert (DEF__146 (- 0 1))) +; print_checker_assertion +(assert (DEF__147 (- 0 1))) +; print_checker_assertion +(assert (DEF__148 (- 0 1))) +; print_checker_assertion +(assert (DEF__149 (- 0 1))) +; print_checker_assertion +(assert (DEF__150 (- 0 1))) +; print_checker_assertion +(assert (DEF__151 (- 0 1))) +; print_checker_assertion +(assert (DEF__152 (- 0 1))) +; print_checker_assertion +(assert (DEF__153 (- 0 1))) +; print_checker_assertion +(assert (DEF__154 (- 0 1))) +; print_checker_assertion +(assert (DEF__155 (- 0 1))) +; print_checker_assertion +(assert (DEF__156 (- 0 1))) +; print_checker_assertion +(assert (DEF__157 (- 0 1))) +; print_checker_assertion +(assert (DEF__115 (- 0 1))) +; print_checker_assertion +(assert (DEF__158 (- 0 1))) +; print_checker_assertion +(assert (DEF__159 (- 0 1))) +; print_checker_assertion +(assert (DEF__160 (- 0 1))) +; print_checker_assertion +(assert (DEF__161 (- 0 1))) +; print_checker_assertion +(assert (DEF__119 (- 0 1))) +; print_checker_assertion +(assert (DEF__162 (- 0 1))) +; print_checker_assertion +(assert (DEF__120 (- 0 1))) +; print_checker_assertion +(assert (DEF__163 (- 0 1))) +; print_checker_assertion +(assert (DEF__121 (- 0 1))) +; print_checker_assertion +(assert (DEF__164 (- 0 1))) +; print_checker_assertion +(assert (DEF__122 (- 0 1))) +; print_checker_assertion +(assert (DEF__165 (- 0 1))) +; print_checker_assertion +(assert (DEF__123 (- 0 1))) +; print_checker_assertion +(assert (DEF__166 (- 0 1))) +; print_checker_assertion +(assert (DEF__124 (- 0 1))) +; print_checker_assertion +(assert (DEF__167 (- 0 1))) +; print_checker_assertion +(assert (DEF__125 (- 0 1))) +; print_checker_assertion +(assert (DEF__168 (- 0 1))) +; print_checker_assertion +(assert (DEF__126 (- 0 1))) +; print_checker_assertion +(assert (DEF__169 (- 0 1))) +; print_checker_assertion +(assert (DEF__170 (- 0 1))) +; print_checker_assertion +(assert (DEF__171 (- 0 1))) +; print_checker_assertion + +; Checking k=2 base +; not refinement_pass +(assert (not (=> (= _base (- 0 1)) (and (P (- 0 1)) (P 0))))) +(assert true) +(check-sat) diff --git a/test/regress/regress1/uflia/simple_cyclic2.smt2 b/test/regress/regress1/uflia/simple_cyclic2.smt2 new file mode 100644 index 000000000..7a0b39999 --- /dev/null +++ b/test/regress/regress1/uflia/simple_cyclic2.smt2 @@ -0,0 +1,44 @@ +(set-logic QF_UFIDL) +(set-info :source | +Benchmark generated from the verification of programs manipulating linked lists inside UCLID. For more information see: +"Verifying properties of well-founded linked lists", Shuvendu Lahiri and Shaz Qaader, POPL 2006 + +This benchmark was automatically translated into SMT-LIB format by Albert Oliveras. +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun t.l () Int) +(declare-fun en_LOCATION () Int) +(declare-fun NULL () Int) +(declare-fun ZERO () Int) +(declare-fun i1 () Int) +(declare-fun t.l0 () Int) +(declare-fun t.pc () Int) +(declare-fun t.t () Int) +(declare-fun PRED_VAR__p_0 () Bool) +(declare-fun PRED_VAR__p_1 () Bool) +(declare-fun PRED_VAR__p_2 () Bool) +(declare-fun PRED_VAR__p_16 () Bool) +(declare-fun PRED_VAR__p_11 () Bool) +(declare-fun PRED_VAR__p_10 () Bool) +(declare-fun PRED_VAR__p_14 () Bool) +(declare-fun PRED_VAR__p_12 () Bool) +(declare-fun PRED_VAR__p_15 () Bool) +(declare-fun PRED_VAR__p_18 () Bool) +(declare-fun PRED_VAR__p_19 () Bool) +(declare-fun PRED_VAR__p_3 () Bool) +(declare-fun PRED_VAR__p_20 () Bool) +(declare-fun PRED_VAR__p_8 () Bool) +(declare-fun PRED_VAR__p_9 () Bool) +(declare-fun t.I_nxt (Int) Int) +(declare-fun t.I_nxt0 (Int) Int) +(declare-fun t.data (Int) Int) +(declare-fun t.nxt (Int) Int) +(declare-fun t.H_nxt (Int) Bool) +(declare-fun t.R_nxt (Int Int) Bool) +(declare-fun t.H_nxt0 (Int) Bool) +(declare-fun t.R_nxt0 (Int Int) Bool) +(assert (let ((?v_0 (t.nxt t.l))) (let ((?v_7 (t.H_nxt ?v_0)) (?v_242 (+ 1 (+ 1 (+ 1 (+ 1 en_LOCATION)))))) (let ((?v_1 (= t.pc ?v_242)) (?v_2 (t.R_nxt ?v_0 i1))) (let ((?v_3 (not ?v_1))) (let ((?v_6 (or (and ?v_1 ?v_2) (and ?v_3 ?v_2))) (?v_4 (t.R_nxt t.l i1))) (let ((?v_247 (or (and ?v_1 ?v_4) (and ?v_3 ?v_4))) (?v_112 (= i1 t.l))) (let ((?v_5 (and ?v_247 (not ?v_112))) (?v_8 (t.R_nxt ?v_0 t.l)) (?v_9 (t.R_nxt ?v_0 t.t))) (let ((?v_12 (or (and ?v_1 ?v_9) (and ?v_3 ?v_9))) (?v_10 (t.R_nxt t.l t.t)) (?v_127 (= t.t t.l))) (let ((?v_22 (not ?v_127))) (let ((?v_11 (and (or (and ?v_1 ?v_10) (and ?v_3 ?v_10)) ?v_22)) (?v_13 (t.R_nxt ?v_0 ?v_0))) (let ((?v_16 (or (and ?v_1 ?v_13) (and ?v_3 ?v_13))) (?v_14 (t.R_nxt t.l ?v_0)) (?v_55 (= ?v_0 t.l))) (let ((?v_15 (and (or (and ?v_1 ?v_14) (and ?v_3 ?v_14)) (not ?v_55))) (?v_18 (t.nxt t.t))) (let ((?v_17 (t.R_nxt ?v_0 ?v_18))) (let ((?v_21 (or (and ?v_1 ?v_17) (and ?v_3 ?v_17))) (?v_19 (t.R_nxt t.l ?v_18)) (?v_72 (= ?v_18 t.l))) (let ((?v_20 (and (or (and ?v_1 ?v_19) (and ?v_3 ?v_19)) (not ?v_72))) (?v_31 (t.H_nxt ?v_18)) (?v_147 (= t.pc en_LOCATION))) (let ((?v_23 (and ?v_147 ?v_22)) (?v_24 (t.R_nxt ?v_18 i1))) (let ((?v_26 (not ?v_23))) (let ((?v_25 (and ?v_26 ?v_24))) (let ((?v_30 (or (and ?v_23 (or (and ?v_23 ?v_24) ?v_25)) ?v_25)) (?v_27 (t.R_nxt t.t i1))) (let ((?v_28 (and ?v_26 ?v_27)) (?v_116 (= i1 t.t))) (let ((?v_29 (and (or (and ?v_23 (or (and ?v_23 ?v_27) ?v_28)) ?v_28) (not ?v_116))) (?v_32 (t.R_nxt ?v_18 t.l))) (let ((?v_33 (and ?v_26 ?v_32))) (let ((?v_37 (or (and ?v_23 (or (and ?v_23 ?v_32) ?v_33)) ?v_33)) (?v_34 (t.R_nxt t.t t.l))) (let ((?v_35 (and ?v_26 ?v_34))) (let ((?v_36 (and (or (and ?v_23 (or (and ?v_23 ?v_34) ?v_35)) ?v_35) ?v_22)) (?v_38 (t.R_nxt ?v_18 t.t))) (let ((?v_39 (and ?v_26 ?v_38)) (?v_40 (t.R_nxt ?v_18 ?v_0))) (let ((?v_41 (and ?v_26 ?v_40))) (let ((?v_45 (or (and ?v_23 (or (and ?v_23 ?v_40) ?v_41)) ?v_41)) (?v_42 (t.R_nxt t.t ?v_0))) (let ((?v_43 (and ?v_26 ?v_42)) (?v_60 (= ?v_0 t.t))) (let ((?v_44 (and (or (and ?v_23 (or (and ?v_23 ?v_42) ?v_43)) ?v_43) (not ?v_60))) (?v_46 (t.R_nxt ?v_18 ?v_18))) (let ((?v_47 (and ?v_26 ?v_46))) (let ((?v_51 (or (and ?v_23 (or (and ?v_23 ?v_46) ?v_47)) ?v_47)) (?v_48 (t.R_nxt t.t ?v_18))) (let ((?v_49 (and ?v_26 ?v_48)) (?v_78 (= ?v_18 t.t))) (let ((?v_50 (and (or (and ?v_23 (or (and ?v_23 ?v_48) ?v_49)) ?v_49) (not ?v_78))) (?v_54 (t.I_nxt t.l))) (let ((?v_53 (= ?v_54 i1)) (?v_67 (t.H_nxt i1)) (?v_120 (= i1 ?v_0)) (?v_56 (not ?v_7)) (?v_57 (t.I_nxt ?v_0))) (let ((?v_86 (= i1 ?v_57))) (let ((?v_52 (or (and ?v_67 ?v_120) (and ?v_56 ?v_86))) (?v_59 (= ?v_54 t.l))) (let ((?v_260 (not ?v_59)) (?v_71 (t.H_nxt t.l)) (?v_89 (= ?v_57 t.l))) (let ((?v_58 (or (and ?v_71 ?v_55) (and ?v_56 ?v_89))) (?v_62 (= ?v_54 t.t)) (?v_77 (t.H_nxt t.t)) (?v_93 (= t.t ?v_57))) (let ((?v_61 (or (and ?v_77 ?v_60) (and ?v_56 ?v_93))) (?v_64 (= ?v_54 ?v_0)) (?v_95 (= ?v_0 ?v_57))) (let ((?v_63 (or ?v_7 ?v_95)) (?v_66 (= ?v_54 ?v_18)) (?v_81 (= ?v_18 ?v_0)) (?v_97 (= ?v_18 ?v_57))) (let ((?v_65 (or (and ?v_31 ?v_81) (and ?v_56 ?v_97))) (?v_70 (t.I_nxt t.t))) (let ((?v_69 (= ?v_70 i1)) (?v_123 (= i1 ?v_18)) (?v_73 (not ?v_31)) (?v_74 (t.I_nxt ?v_18))) (let ((?v_99 (= i1 ?v_74))) (let ((?v_68 (or (and ?v_67 ?v_123) (and ?v_73 ?v_99))) (?v_76 (= ?v_70 t.l)) (?v_102 (= ?v_74 t.l))) (let ((?v_75 (or (and ?v_71 ?v_72) (and ?v_73 ?v_102))) (?v_80 (= ?v_70 t.t)) (?v_106 (= t.t ?v_74))) (let ((?v_79 (or (and ?v_77 ?v_78) (and ?v_73 ?v_106))) (?v_83 (= ?v_70 ?v_0)) (?v_108 (= ?v_0 ?v_74))) (let ((?v_82 (or (and ?v_7 ?v_81) (and ?v_73 ?v_108))) (?v_85 (= ?v_70 ?v_18)) (?v_110 (= ?v_18 ?v_74))) (let ((?v_84 (or ?v_31 ?v_110)) (?v_87 (t.nxt ?v_0))) (let ((?v_90 (not (t.H_nxt ?v_87))) (?v_91 (t.I_nxt ?v_87))) (let ((?v_88 (or (and ?v_67 (= i1 ?v_87)) (and ?v_90 (= i1 ?v_91)))) (?v_92 (or (and ?v_71 (= t.l ?v_87)) (and ?v_90 (= t.l ?v_91)))) (?v_94 (or (and ?v_77 (= t.t ?v_87)) (and ?v_90 (= t.t ?v_91)))) (?v_96 (or (and ?v_7 (= ?v_0 ?v_87)) (and ?v_90 (= ?v_0 ?v_91)))) (?v_98 (or (and ?v_31 (= ?v_18 ?v_87)) (and ?v_90 (= ?v_18 ?v_91)))) (?v_100 (t.nxt ?v_18))) (let ((?v_103 (not (t.H_nxt ?v_100))) (?v_104 (t.I_nxt ?v_100))) (let ((?v_101 (or (and ?v_67 (= i1 ?v_100)) (and ?v_103 (= i1 ?v_104)))) (?v_105 (or (and ?v_71 (= t.l ?v_100)) (and ?v_103 (= t.l ?v_104)))) (?v_107 (or (and ?v_77 (= t.t ?v_100)) (and ?v_103 (= t.t ?v_104)))) (?v_109 (or (and ?v_7 (= ?v_0 ?v_100)) (and ?v_103 (= ?v_0 ?v_104)))) (?v_111 (or (and ?v_31 (= ?v_18 ?v_100)) (and ?v_103 (= ?v_18 ?v_104)))) (?v_156 (t.R_nxt i1 i1)) (?v_115 (t.R_nxt i1 t.l)) (?v_113 (t.nxt i1))) (let ((?v_117 (not (t.H_nxt ?v_113)))) (let ((?v_114 (or ?v_112 (and ?v_117 (t.R_nxt ?v_113 t.l)))) (?v_119 (t.R_nxt i1 t.t)) (?v_118 (or ?v_116 (and ?v_117 (t.R_nxt ?v_113 t.t)))) (?v_122 (t.R_nxt i1 ?v_0)) (?v_121 (or ?v_120 (and ?v_117 (t.R_nxt ?v_113 ?v_0)))) (?v_125 (t.R_nxt i1 ?v_18)) (?v_124 (or ?v_123 (and ?v_117 (t.R_nxt ?v_113 ?v_18)))) (?v_149 (not ?v_4)) (?v_126 (or ?v_112 (and ?v_56 ?v_2))) (?v_169 (t.R_nxt t.l t.l)) (?v_190 (not ?v_10)) (?v_128 (or ?v_127 (and ?v_56 ?v_9))) (?v_209 (not ?v_14)) (?v_129 (or ?v_55 (and ?v_56 ?v_13))) (?v_227 (not ?v_19)) (?v_130 (or ?v_72 (and ?v_56 ?v_17))) (?v_157 (not ?v_27)) (?v_131 (or ?v_116 (and ?v_73 ?v_24))) (?v_178 (not ?v_34)) (?v_132 (or ?v_127 (and ?v_73 ?v_32))) (?v_196 (t.R_nxt t.t t.t)) (?v_214 (not ?v_42)) (?v_133 (or ?v_60 (and ?v_73 ?v_40))) (?v_232 (not ?v_48)) (?v_134 (or ?v_78 (and ?v_73 ?v_46))) (?v_135 (or ?v_120 (and ?v_90 (t.R_nxt ?v_87 i1)))) (?v_136 (or ?v_55 (and ?v_90 (t.R_nxt ?v_87 t.l)))) (?v_137 (or ?v_60 (and ?v_90 (t.R_nxt ?v_87 t.t)))) (?v_138 (or ?v_81 (and ?v_90 (t.R_nxt ?v_87 ?v_18)))) (?v_139 (or ?v_123 (and ?v_103 (t.R_nxt ?v_100 i1)))) (?v_140 (or ?v_72 (and ?v_103 (t.R_nxt ?v_100 t.l)))) (?v_141 (or ?v_78 (and ?v_103 (t.R_nxt ?v_100 t.t)))) (?v_142 (or ?v_81 (and ?v_103 (t.R_nxt ?v_100 ?v_0)))) (?v_146 (= (t.I_nxt0 t.l0) t.l0)) (?v_143 (= i1 NULL)) (?v_145 (t.H_nxt0 i1)) (?v_144 (= t.l t.l0)) (?v_168 (= t.l NULL)) (?v_170 (t.H_nxt0 t.l)) (?v_187 (= t.t NULL)) (?v_188 (t.H_nxt0 t.t)) (?v_206 (= ?v_0 NULL)) (?v_207 (t.H_nxt0 ?v_0)) (?v_224 (= ?v_18 NULL)) (?v_225 (t.H_nxt0 ?v_18))) (let ((?v_148 (not ?v_143)) (?v_150 (t.R_nxt0 t.l i1)) (?v_152 (and ?v_146 (and ?v_1 (not ?v_147))))) (let ((?v_151 (and ?v_145 ?v_152))) (let ((?v_160 (and ?v_22 (and ?v_59 (and ?v_67 (and ?v_4 (and ?v_144 (and ?v_150 ?v_151))))))) (?v_154 (not ?v_150))) (let ((?v_161 (and ?v_22 (and ?v_59 (and ?v_67 (and ?v_149 (and ?v_144 (and ?v_154 ?v_151))))))) (?v_153 (not ?v_67)) (?v_158 (not ?v_145))) (let ((?v_155 (and ?v_158 ?v_152)) (?v_159 (and ?v_146 (and ?v_147 ?v_3)))) (let ((?v_163 (and ?v_145 ?v_159)) (?v_164 (and ?v_158 ?v_159)) (?v_162 (not ?v_156))) (let ((?v_165 (and ?v_59 (and ?v_67 (and ?v_4 (and ?v_144 (and ?v_150 ?v_163))))))) (let ((?v_167 (and ?v_22 ?v_165)) (?v_258 (t.data i1))) (let ((?v_166 (= ?v_258 ZERO)) (?v_171 (not ?v_168)) (?v_172 (t.R_nxt0 t.l t.l)) (?v_173 (and ?v_170 ?v_152))) (let ((?v_180 (and ?v_22 (and ?v_59 (and ?v_71 (and ?v_169 (and ?v_144 (and ?v_172 ?v_173))))))) (?v_175 (not ?v_169)) (?v_176 (not ?v_172))) (let ((?v_181 (and ?v_22 (and ?v_59 (and ?v_71 (and ?v_175 (and ?v_144 (and ?v_176 ?v_173))))))) (?v_174 (not ?v_71)) (?v_179 (not ?v_170))) (let ((?v_177 (and ?v_179 ?v_152)) (?v_182 (and ?v_170 ?v_159)) (?v_183 (and ?v_179 ?v_159))) (let ((?v_184 (and ?v_59 (and ?v_71 (and ?v_169 (and ?v_144 (and ?v_172 ?v_182))))))) (let ((?v_186 (and ?v_22 ?v_184)) (?v_185 (= (t.data t.l) ZERO)) (?v_189 (not ?v_187)) (?v_191 (t.R_nxt0 t.l t.t)) (?v_192 (and ?v_188 ?v_152))) (let ((?v_199 (and ?v_22 (and ?v_59 (and ?v_77 (and ?v_10 (and ?v_144 (and ?v_191 ?v_192))))))) (?v_194 (not ?v_191))) (let ((?v_200 (and ?v_22 (and ?v_59 (and ?v_77 (and ?v_190 (and ?v_144 (and ?v_194 ?v_192))))))) (?v_193 (not ?v_77)) (?v_198 (not ?v_188))) (let ((?v_195 (and ?v_198 ?v_152)) (?v_197 (not ?v_196)) (?v_201 (and ?v_188 ?v_159)) (?v_202 (and ?v_198 ?v_159))) (let ((?v_203 (and ?v_59 (and ?v_77 (and ?v_10 (and ?v_144 (and ?v_191 ?v_201))))))) (let ((?v_205 (and ?v_22 ?v_203)) (?v_204 (= (t.data t.t) ZERO)) (?v_208 (not ?v_206)) (?v_210 (t.R_nxt0 t.l ?v_0)) (?v_211 (and ?v_207 ?v_152))) (let ((?v_216 (and ?v_22 (and ?v_59 (and ?v_7 (and ?v_14 (and ?v_144 (and ?v_210 ?v_211))))))) (?v_212 (not ?v_210))) (let ((?v_217 (and ?v_22 (and ?v_59 (and ?v_7 (and ?v_209 (and ?v_144 (and ?v_212 ?v_211))))))) (?v_215 (not ?v_207))) (let ((?v_213 (and ?v_215 ?v_152)) (?v_219 (and ?v_207 ?v_159)) (?v_220 (and ?v_215 ?v_159)) (?v_218 (not ?v_13))) (let ((?v_221 (and ?v_59 (and ?v_7 (and ?v_14 (and ?v_144 (and ?v_210 ?v_219))))))) (let ((?v_223 (and ?v_22 ?v_221)) (?v_222 (= (t.data ?v_0) ZERO)) (?v_226 (not ?v_224)) (?v_228 (t.R_nxt0 t.l ?v_18)) (?v_229 (and ?v_225 ?v_152))) (let ((?v_234 (and ?v_22 (and ?v_59 (and ?v_31 (and ?v_19 (and ?v_144 (and ?v_228 ?v_229))))))) (?v_230 (not ?v_228))) (let ((?v_235 (and ?v_22 (and ?v_59 (and ?v_31 (and ?v_227 (and ?v_144 (and ?v_230 ?v_229))))))) (?v_233 (not ?v_225))) (let ((?v_231 (and ?v_233 ?v_152)) (?v_237 (and ?v_225 ?v_159)) (?v_238 (and ?v_233 ?v_159)) (?v_236 (not ?v_46))) (let ((?v_239 (and ?v_59 (and ?v_31 (and ?v_19 (and ?v_144 (and ?v_228 ?v_237))))))) (let ((?v_241 (and ?v_22 ?v_239)) (?v_240 (= (t.data ?v_18) ZERO)) (?v_246 (or ?v_1 ?v_23))) (let ((?v_244 (ite ?v_246 en_LOCATION (+ 1 (+ 1 ?v_242))))) (let ((?v_243 (= ?v_244 ?v_242)) (?v_278 (not PRED_VAR__p_0)) (?v_245 (= ?v_244 en_LOCATION)) (?v_269 (not PRED_VAR__p_1)) (?v_274 (not PRED_VAR__p_3)) (?v_271 (not PRED_VAR__p_16)) (?v_248 (and ?v_26 ?v_4)) (?v_254 (not ?v_246)) (?v_249 (and ?v_147 ?v_127))) (let ((?v_255 (not ?v_249))) (let ((?v_250 (and ?v_255 ?v_4))) (let ((?v_251 (or (and ?v_246 (or (and ?v_1 ?v_247) (and ?v_3 (or (and ?v_23 (or (and ?v_23 (or (and ?v_23 ?v_4) ?v_248)) ?v_248)) ?v_248)))) (and ?v_254 (or (and ?v_249 (or (and ?v_249 ?v_4) ?v_250)) ?v_250)))) (?v_270 (not PRED_VAR__p_8)) (?v_261 (ite ?v_246 (ite ?v_1 ?v_0 (ite ?v_23 ?v_18 t.t)) t.t))) (let ((?v_252 (t.R_nxt ?v_261 i1))) (let ((?v_253 (and ?v_26 ?v_252)) (?v_256 (and ?v_255 ?v_252))) (let ((?v_257 (or (and ?v_246 (or (and ?v_1 (or (and ?v_1 ?v_252) (and ?v_3 ?v_252))) (and ?v_3 (or (and ?v_23 (or (and ?v_23 (or (and ?v_23 ?v_252) ?v_253)) ?v_253)) ?v_253)))) (and ?v_254 (or (and ?v_249 (or (and ?v_249 ?v_252) ?v_256)) ?v_256)))) (?v_277 (not PRED_VAR__p_9)) (?v_273 (not PRED_VAR__p_14)) (?v_259 (= (ite ?v_246 (ite ?v_1 (ite ?v_1 (ite ?v_112 ZERO ?v_258) ?v_258) (ite ?v_23 (ite ?v_23 (ite ?v_116 ZERO ?v_258) ?v_258) ?v_258)) ?v_258) ZERO)) (?v_262 (= (t.I_nxt ?v_261) t.l)) (?v_263 (= ?v_261 t.l)) (?v_268 (not PRED_VAR__p_18)) (?v_267 (not PRED_VAR__p_19)) (?v_264 (and ?v_26 ?v_156)) (?v_265 (and ?v_255 ?v_156))) (let ((?v_266 (or (and ?v_246 (or (and ?v_1 (or (and ?v_1 ?v_156) (and ?v_3 ?v_156))) (and ?v_3 (or (and ?v_23 (or (and ?v_23 (or (and ?v_23 ?v_156) ?v_264)) ?v_264)) ?v_264)))) (and ?v_254 (or (and ?v_249 (or (and ?v_249 ?v_156) ?v_265)) ?v_265)))) (?v_281 (not PRED_VAR__p_20)) (?v_275 (and PRED_VAR__p_2 (and PRED_VAR__p_0 ?v_269)))) (let ((?v_272 (and PRED_VAR__p_3 ?v_275))) (let ((?v_280 (and ?v_268 (and PRED_VAR__p_10 (and PRED_VAR__p_14 (and PRED_VAR__p_8 (and PRED_VAR__p_11 (and PRED_VAR__p_16 ?v_272))))))) (?v_282 (and ?v_268 (and PRED_VAR__p_10 (and PRED_VAR__p_14 (and ?v_270 (and PRED_VAR__p_11 (and ?v_271 ?v_272))))))) (?v_276 (and ?v_274 ?v_275)) (?v_279 (and PRED_VAR__p_2 (and PRED_VAR__p_1 ?v_278)))) (let ((?v_283 (and PRED_VAR__p_3 ?v_279)) (?v_284 (and ?v_274 ?v_279))) (let ((?v_285 (and PRED_VAR__p_10 (and PRED_VAR__p_14 (and PRED_VAR__p_8 (and PRED_VAR__p_11 (and PRED_VAR__p_16 ?v_283))))))) (let ((?v_286 (and ?v_268 ?v_285))) (and (and (and (and (and (and (and (and (and (and (or ?v_7 (and (or (not ?v_6) ?v_5) (or (not ?v_5) ?v_6))) (and (or ?v_7 (not (or (and ?v_1 ?v_8) (and ?v_3 ?v_8)))) (and (or ?v_7 (and (or (not ?v_12) ?v_11) (or (not ?v_11) ?v_12))) (and (or ?v_7 (and (or (not ?v_16) ?v_15) (or (not ?v_15) ?v_16))) (or ?v_7 (and (or (not ?v_21) ?v_20) (or (not ?v_20) ?v_21))))))) (and (or ?v_31 (and (or (not ?v_30) ?v_29) (or (not ?v_29) ?v_30))) (and (or ?v_31 (and (or (not ?v_37) ?v_36) (or (not ?v_36) ?v_37))) (and (or ?v_31 (not (or (and ?v_23 (or (and ?v_23 ?v_38) ?v_39)) ?v_39))) (and (or ?v_31 (and (or (not ?v_45) ?v_44) (or (not ?v_44) ?v_45))) (or ?v_31 (and (or (not ?v_51) ?v_50) (or (not ?v_50) ?v_51)))))))) (and (and (or (not ?v_53) ?v_52) (or (not ?v_52) ?v_53)) (and (and (or ?v_260 ?v_58) (or (not ?v_58) ?v_59)) (and (and (or (not ?v_62) ?v_61) (or (not ?v_61) ?v_62)) (and (and (or (not ?v_64) ?v_63) (or (not ?v_63) ?v_64)) (and (and (or (not ?v_66) ?v_65) (or (not ?v_65) ?v_66)) (and (and (or (not ?v_69) ?v_68) (or (not ?v_68) ?v_69)) (and (and (or (not ?v_76) ?v_75) (or (not ?v_75) ?v_76)) (and (and (or (not ?v_80) ?v_79) (or (not ?v_79) ?v_80)) (and (and (or (not ?v_83) ?v_82) (or (not ?v_82) ?v_83)) (and (and (or (not ?v_85) ?v_84) (or (not ?v_84) ?v_85)) (and (and (or (not ?v_86) ?v_88) (or (not ?v_88) ?v_86)) (and (and (or (not ?v_89) ?v_92) (or (not ?v_92) ?v_89)) (and (and (or (not ?v_93) ?v_94) (or (not ?v_94) ?v_93)) (and (and (or (not ?v_95) ?v_96) (or (not ?v_96) ?v_95)) (and (and (or (not ?v_97) ?v_98) (or (not ?v_98) ?v_97)) (and (and (or (not ?v_99) ?v_101) (or (not ?v_101) ?v_99)) (and (and (or (not ?v_102) ?v_105) (or (not ?v_105) ?v_102)) (and (and (or (not ?v_106) ?v_107) (or (not ?v_107) ?v_106)) (and (and (or (not ?v_108) ?v_109) (or (not ?v_109) ?v_108)) (and (or (not ?v_110) ?v_111) (or (not ?v_111) ?v_110)))))))))))))))))))))) (and ?v_156 (and (and (or (not ?v_115) ?v_114) (or (not ?v_114) ?v_115)) (and (and (or (not ?v_119) ?v_118) (or (not ?v_118) ?v_119)) (and (and (or (not ?v_122) ?v_121) (or (not ?v_121) ?v_122)) (and (and (or (not ?v_125) ?v_124) (or (not ?v_124) ?v_125)) (and (and (or ?v_149 ?v_126) (or (not ?v_126) ?v_4)) (and ?v_169 (and (and (or ?v_190 ?v_128) (or (not ?v_128) ?v_10)) (and (and (or ?v_209 ?v_129) (or (not ?v_129) ?v_14)) (and (and (or ?v_227 ?v_130) (or (not ?v_130) ?v_19)) (and (and (or ?v_157 ?v_131) (or (not ?v_131) ?v_27)) (and (and (or ?v_178 ?v_132) (or (not ?v_132) ?v_34)) (and ?v_196 (and (and (or ?v_214 ?v_133) (or (not ?v_133) ?v_42)) (and (and (or ?v_232 ?v_134) (or (not ?v_134) ?v_48)) (and (and (or (not ?v_2) ?v_135) (or (not ?v_135) ?v_2)) (and (and (or (not ?v_8) ?v_136) (or (not ?v_136) ?v_8)) (and (and (or (not ?v_9) ?v_137) (or (not ?v_137) ?v_9)) (and ?v_13 (and (and (or (not ?v_17) ?v_138) (or (not ?v_138) ?v_17)) (and (and (or (not ?v_24) ?v_139) (or (not ?v_139) ?v_24)) (and (and (or (not ?v_32) ?v_140) (or (not ?v_140) ?v_32)) (and (and (or (not ?v_38) ?v_141) (or (not ?v_141) ?v_38)) (and (and (or (not ?v_40) ?v_142) (or (not ?v_142) ?v_40)) ?v_46))))))))))))))))))))))))) (and (t.H_nxt NULL) (= (t.nxt NULL) NULL))) ?v_146) (and (or (not (or (= i1 t.l0) ?v_143)) ?v_145) (and (or (not (or ?v_144 ?v_168)) ?v_170) (and (or (not (or (= t.t t.l0) ?v_187)) ?v_188) (and (or (not (or (= ?v_0 t.l0) ?v_206)) ?v_207) (or (not (or (= ?v_18 t.l0) ?v_224)) ?v_225)))))) (not (= NULL t.l0))) (and (and (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_148 ?v_160) (and ?v_148 ?v_161)) (and ?v_148 (and ?v_22 (and ?v_59 (and ?v_153 (and ?v_4 (and ?v_144 (and ?v_150 ?v_155)))))))) (and ?v_148 (and ?v_22 (and ?v_59 (and ?v_153 (and ?v_149 (and ?v_144 (and ?v_154 ?v_155)))))))) (and ?v_76 (and ?v_156 (and ?v_157 (and ?v_59 (and ?v_67 (and ?v_149 (and ?v_144 (and ?v_154 ?v_163))))))))) (and ?v_76 (and ?v_156 (and ?v_157 (and ?v_148 (and ?v_59 (and ?v_153 (and ?v_149 (and ?v_144 (and ?v_154 ?v_164)))))))))) (and ?v_156 (and ?v_27 ?v_160))) (and ?v_162 (and ?v_157 ?v_160))) (and ?v_156 (and ?v_27 ?v_161))) (and ?v_162 (and ?v_157 ?v_161))) (and ?v_76 (and ?v_156 (and ?v_27 ?v_167)))) (and ?v_76 (and ?v_156 (and ?v_27 (and ?v_148 (and ?v_22 (and ?v_59 (and ?v_153 (and ?v_4 (and ?v_144 (and ?v_150 ?v_164))))))))))) (and ?v_166 (and ?v_76 (and ?v_156 (and ?v_27 (and ?v_148 ?v_165)))))) (and ?v_166 (and ?v_76 (and ?v_156 (and ?v_148 ?v_167))))) (and (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_171 ?v_180) (and ?v_171 ?v_181)) (and ?v_171 (and ?v_22 (and ?v_59 (and ?v_174 (and ?v_169 (and ?v_144 (and ?v_172 ?v_177)))))))) (and ?v_171 (and ?v_22 (and ?v_59 (and ?v_174 (and ?v_175 (and ?v_144 (and ?v_176 ?v_177)))))))) (and ?v_76 (and ?v_169 (and ?v_178 (and ?v_59 (and ?v_71 (and ?v_175 (and ?v_144 (and ?v_176 ?v_182))))))))) (and ?v_76 (and ?v_169 (and ?v_178 (and ?v_171 (and ?v_59 (and ?v_174 (and ?v_175 (and ?v_144 (and ?v_176 ?v_183)))))))))) (and ?v_169 (and ?v_34 ?v_180))) (and ?v_175 (and ?v_178 ?v_180))) (and ?v_169 (and ?v_34 ?v_181))) (and ?v_175 (and ?v_178 ?v_181))) (and ?v_76 (and ?v_169 (and ?v_34 ?v_186)))) (and ?v_76 (and ?v_169 (and ?v_34 (and ?v_171 (and ?v_22 (and ?v_59 (and ?v_174 (and ?v_169 (and ?v_144 (and ?v_172 ?v_183))))))))))) (and ?v_185 (and ?v_76 (and ?v_169 (and ?v_34 (and ?v_171 ?v_184)))))) (and ?v_185 (and ?v_76 (and ?v_169 (and ?v_171 ?v_186))))) (and (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_189 ?v_199) (and ?v_189 ?v_200)) (and ?v_189 (and ?v_22 (and ?v_59 (and ?v_193 (and ?v_10 (and ?v_144 (and ?v_191 ?v_195)))))))) (and ?v_189 (and ?v_22 (and ?v_59 (and ?v_193 (and ?v_190 (and ?v_144 (and ?v_194 ?v_195)))))))) (and ?v_76 (and ?v_196 (and ?v_197 (and ?v_59 (and ?v_77 (and ?v_190 (and ?v_144 (and ?v_194 ?v_201))))))))) (and ?v_76 (and ?v_196 (and ?v_197 (and ?v_189 (and ?v_59 (and ?v_193 (and ?v_190 (and ?v_144 (and ?v_194 ?v_202)))))))))) (and ?v_196 (and ?v_196 ?v_199))) (and ?v_197 (and ?v_197 ?v_199))) (and ?v_196 (and ?v_196 ?v_200))) (and ?v_197 (and ?v_197 ?v_200))) (and ?v_76 (and ?v_196 (and ?v_196 ?v_205)))) (and ?v_76 (and ?v_196 (and ?v_196 (and ?v_189 (and ?v_22 (and ?v_59 (and ?v_193 (and ?v_10 (and ?v_144 (and ?v_191 ?v_202))))))))))) (and ?v_204 (and ?v_76 (and ?v_196 (and ?v_196 (and ?v_189 ?v_203)))))) (and ?v_204 (and ?v_76 (and ?v_196 (and ?v_189 ?v_205))))) (and (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_208 ?v_216) (and ?v_208 ?v_217)) (and ?v_208 (and ?v_22 (and ?v_59 (and ?v_56 (and ?v_14 (and ?v_144 (and ?v_210 ?v_213)))))))) (and ?v_208 (and ?v_22 (and ?v_59 (and ?v_56 (and ?v_209 (and ?v_144 (and ?v_212 ?v_213)))))))) (and ?v_76 (and ?v_13 (and ?v_214 (and ?v_59 (and ?v_7 (and ?v_209 (and ?v_144 (and ?v_212 ?v_219))))))))) (and ?v_76 (and ?v_13 (and ?v_214 (and ?v_208 (and ?v_59 (and ?v_56 (and ?v_209 (and ?v_144 (and ?v_212 ?v_220)))))))))) (and ?v_13 (and ?v_42 ?v_216))) (and ?v_218 (and ?v_214 ?v_216))) (and ?v_13 (and ?v_42 ?v_217))) (and ?v_218 (and ?v_214 ?v_217))) (and ?v_76 (and ?v_13 (and ?v_42 ?v_223)))) (and ?v_76 (and ?v_13 (and ?v_42 (and ?v_208 (and ?v_22 (and ?v_59 (and ?v_56 (and ?v_14 (and ?v_144 (and ?v_210 ?v_220))))))))))) (and ?v_222 (and ?v_76 (and ?v_13 (and ?v_42 (and ?v_208 ?v_221)))))) (and ?v_222 (and ?v_76 (and ?v_13 (and ?v_208 ?v_223))))) (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_226 ?v_234) (and ?v_226 ?v_235)) (and ?v_226 (and ?v_22 (and ?v_59 (and ?v_73 (and ?v_19 (and ?v_144 (and ?v_228 ?v_231)))))))) (and ?v_226 (and ?v_22 (and ?v_59 (and ?v_73 (and ?v_227 (and ?v_144 (and ?v_230 ?v_231)))))))) (and ?v_76 (and ?v_46 (and ?v_232 (and ?v_59 (and ?v_31 (and ?v_227 (and ?v_144 (and ?v_230 ?v_237))))))))) (and ?v_76 (and ?v_46 (and ?v_232 (and ?v_226 (and ?v_59 (and ?v_73 (and ?v_227 (and ?v_144 (and ?v_230 ?v_238)))))))))) (and ?v_46 (and ?v_48 ?v_234))) (and ?v_236 (and ?v_232 ?v_234))) (and ?v_46 (and ?v_48 ?v_235))) (and ?v_236 (and ?v_232 ?v_235))) (and ?v_76 (and ?v_46 (and ?v_48 ?v_241)))) (and ?v_76 (and ?v_46 (and ?v_48 (and ?v_226 (and ?v_22 (and ?v_59 (and ?v_73 (and ?v_19 (and ?v_144 (and ?v_228 ?v_238))))))))))) (and ?v_240 (and ?v_76 (and ?v_46 (and ?v_48 (and ?v_226 ?v_239)))))) (and ?v_240 (and ?v_76 (and ?v_46 (and ?v_226 ?v_241))))))))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (or (and PRED_VAR__p_0 ?v_243) (and ?v_278 (not ?v_243))) (or (and PRED_VAR__p_1 ?v_245) (and ?v_269 (not ?v_245)))) (or (and PRED_VAR__p_2 ?v_146) (and (not PRED_VAR__p_2) (not ?v_146)))) (or (and PRED_VAR__p_3 ?v_145) (and ?v_274 ?v_158))) (or (and PRED_VAR__p_16 ?v_150) (and ?v_271 ?v_154))) (or (and PRED_VAR__p_11 ?v_144) (and (not PRED_VAR__p_11) (not ?v_144)))) (or (and PRED_VAR__p_8 ?v_251) (and ?v_270 (not ?v_251)))) (or (and PRED_VAR__p_9 ?v_257) (and ?v_277 (not ?v_257)))) (or (and PRED_VAR__p_14 ?v_67) (and ?v_273 ?v_153))) (or (and PRED_VAR__p_15 ?v_259) (and (not PRED_VAR__p_15) (not ?v_259)))) (or (and PRED_VAR__p_10 ?v_59) (and (not PRED_VAR__p_10) ?v_260))) (or (and PRED_VAR__p_12 ?v_262) (and (not PRED_VAR__p_12) (not ?v_262)))) (or (and PRED_VAR__p_18 ?v_263) (and ?v_268 (not ?v_263)))) (or (and PRED_VAR__p_19 ?v_143) (and ?v_267 ?v_148))) (or (and PRED_VAR__p_20 ?v_266) (and ?v_281 (not ?v_266)))))) (not (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_267 ?v_280) (and ?v_267 ?v_282)) (and ?v_267 (and ?v_268 (and PRED_VAR__p_10 (and ?v_273 (and PRED_VAR__p_8 (and PRED_VAR__p_11 (and PRED_VAR__p_16 ?v_276)))))))) (and ?v_267 (and ?v_268 (and PRED_VAR__p_10 (and ?v_273 (and ?v_270 (and PRED_VAR__p_11 (and ?v_271 ?v_276)))))))) (and PRED_VAR__p_12 (and PRED_VAR__p_20 (and ?v_277 (and PRED_VAR__p_10 (and PRED_VAR__p_14 (and ?v_270 (and PRED_VAR__p_11 (and ?v_271 ?v_283))))))))) (and PRED_VAR__p_12 (and PRED_VAR__p_20 (and ?v_277 (and ?v_267 (and PRED_VAR__p_10 (and ?v_273 (and ?v_270 (and PRED_VAR__p_11 (and ?v_271 ?v_284)))))))))) (and PRED_VAR__p_20 (and PRED_VAR__p_9 ?v_280))) (and ?v_281 (and ?v_277 ?v_280))) (and PRED_VAR__p_20 (and PRED_VAR__p_9 ?v_282))) (and ?v_281 (and ?v_277 ?v_282))) (and PRED_VAR__p_12 (and PRED_VAR__p_20 (and PRED_VAR__p_9 ?v_286)))) (and PRED_VAR__p_12 (and PRED_VAR__p_20 (and PRED_VAR__p_9 (and ?v_267 (and ?v_268 (and PRED_VAR__p_10 (and ?v_273 (and PRED_VAR__p_8 (and PRED_VAR__p_11 (and PRED_VAR__p_16 ?v_284))))))))))) (and PRED_VAR__p_15 (and PRED_VAR__p_12 (and PRED_VAR__p_20 (and PRED_VAR__p_9 (and ?v_267 ?v_285)))))) (and PRED_VAR__p_15 (and PRED_VAR__p_12 (and PRED_VAR__p_20 (and ?v_267 ?v_286)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/uflia/speed2_e8_449_e8_517.ec.smt2 b/test/regress/regress1/uflia/speed2_e8_449_e8_517.ec.smt2 new file mode 100644 index 000000000..11fdfa51d --- /dev/null +++ b/test/regress/regress1/uflia/speed2_e8_449_e8_517.ec.smt2 @@ -0,0 +1,747 @@ +(set-logic QF_UFLIA) +(declare-fun _base () Int) +(declare-fun _n () Int) +(assert (let ((.def_5 (<= 0 _n))) +.def_5 +)) +(declare-fun ___z2z___ (Int) Bool) +(declare-fun ___z3z___ (Int) Bool) +(declare-fun ___z4z___ (Int) Bool) +(declare-fun ___z5z___ (Int) Bool) +(declare-fun ___z6z___ (Int) Bool) +(declare-fun ___z7z___ (Int) Int) +(declare-fun ___z8z___ (Int) Int) +(declare-fun ___z9z___ (Int) Int) +(push 1) +(assert (let ((.def_152 (___z4z___ 0))) +(let ((.def_150 (= _base 0))) +(let ((.def_147 (___z6z___ (- 1)))) +(let ((.def_148 (not .def_147))) +(let ((.def_145 (___z5z___ 0))) +(let ((.def_146 (not .def_145))) +(let ((.def_149 (and .def_146 .def_148))) +(let ((.def_151 (or .def_149 .def_150))) +(let ((.def_153 (= .def_151 .def_152))) +.def_153 +)))))))))) +(assert (let ((.def_157 (___z7z___ 0))) +(let ((.def_161 (<= .def_157 (- 10)))) +(let ((.def_155 (___z5z___ (- 1)))) +(let ((.def_162 (or .def_155 .def_161))) +(let ((.def_158 (<= 0 .def_157))) +(let ((.def_159 (not .def_158))) +(let ((.def_156 (not .def_155))) +(let ((.def_160 (or .def_156 .def_159))) +(let ((.def_163 (and .def_160 .def_162))) +(let ((.def_150 (= _base 0))) +(let ((.def_164 (or .def_150 .def_163))) +(let ((.def_154 (not .def_150))) +(let ((.def_165 (and .def_154 .def_164))) +(let ((.def_145 (___z5z___ 0))) +(let ((.def_166 (= .def_145 .def_165))) +.def_166 +)))))))))))))))) +(assert (let ((.def_175 (___z6z___ 0))) +(let ((.def_157 (___z7z___ 0))) +(let ((.def_170 (<= 10 .def_157))) +(let ((.def_147 (___z6z___ (- 1)))) +(let ((.def_171 (or .def_147 .def_170))) +(let ((.def_167 (<= .def_157 0))) +(let ((.def_168 (not .def_167))) +(let ((.def_148 (not .def_147))) +(let ((.def_169 (or .def_148 .def_168))) +(let ((.def_172 (and .def_169 .def_171))) +(let ((.def_150 (= _base 0))) +(let ((.def_173 (or .def_150 .def_172))) +(let ((.def_154 (not .def_150))) +(let ((.def_174 (and .def_154 .def_173))) +(let ((.def_176 (= .def_174 .def_175))) +.def_176 +)))))))))))))))) +(assert (let ((.def_177 (___z9z___ 0))) +(let ((.def_178 (___z8z___ 0))) +(let ((.def_179 (+ .def_177 .def_178))) +(let ((.def_181 (___z2z___ 0))) +(let ((.def_180 (___z3z___ 0))) +(let ((.def_182 (and .def_180 .def_181))) +(let ((.def_183 (ite .def_182 .def_179 .def_177))) +(let ((.def_157 (___z7z___ 0))) +(let ((.def_184 (= .def_157 .def_183))) +.def_184 +)))))))))) +(assert (let ((.def_181 (___z2z___ 0))) +(let ((.def_185 (not .def_181))) +(let ((.def_180 (___z3z___ 0))) +(let ((.def_186 (and .def_180 .def_185))) +(let ((.def_187 (ite .def_186 2 0))) +(let ((.def_188 (not .def_180))) +(let ((.def_189 (and .def_181 .def_188))) +(let ((.def_190 (ite .def_189 1 .def_187))) +(let ((.def_178 (___z8z___ 0))) +(let ((.def_191 (= .def_178 .def_190))) +.def_191 +))))))))))) +(assert (let ((.def_192 (___z7z___ (- 1)))) +(let ((.def_150 (= _base 0))) +(let ((.def_193 (ite .def_150 0 .def_192))) +(let ((.def_177 (___z9z___ 0))) +(let ((.def_194 (= .def_177 .def_193))) +.def_194 +)))))) +(assert (let ((.def_201 (___z4z___ (- 1)))) +(let ((.def_199 (= _base (- 1)))) +(let ((.def_196 (___z6z___ (- 2)))) +(let ((.def_197 (not .def_196))) +(let ((.def_155 (___z5z___ (- 1)))) +(let ((.def_156 (not .def_155))) +(let ((.def_198 (and .def_156 .def_197))) +(let ((.def_200 (or .def_198 .def_199))) +(let ((.def_202 (= .def_200 .def_201))) +.def_202 +)))))))))) +(assert (let ((.def_192 (___z7z___ (- 1)))) +(let ((.def_209 (<= .def_192 (- 10)))) +(let ((.def_204 (___z5z___ (- 2)))) +(let ((.def_210 (or .def_204 .def_209))) +(let ((.def_206 (<= 0 .def_192))) +(let ((.def_207 (not .def_206))) +(let ((.def_205 (not .def_204))) +(let ((.def_208 (or .def_205 .def_207))) +(let ((.def_211 (and .def_208 .def_210))) +(let ((.def_199 (= _base (- 1)))) +(let ((.def_212 (or .def_199 .def_211))) +(let ((.def_203 (not .def_199))) +(let ((.def_213 (and .def_203 .def_212))) +(let ((.def_155 (___z5z___ (- 1)))) +(let ((.def_214 (= .def_155 .def_213))) +.def_214 +)))))))))))))))) +(assert (let ((.def_192 (___z7z___ (- 1)))) +(let ((.def_218 (<= 10 .def_192))) +(let ((.def_196 (___z6z___ (- 2)))) +(let ((.def_219 (or .def_196 .def_218))) +(let ((.def_215 (<= .def_192 0))) +(let ((.def_216 (not .def_215))) +(let ((.def_197 (not .def_196))) +(let ((.def_217 (or .def_197 .def_216))) +(let ((.def_220 (and .def_217 .def_219))) +(let ((.def_199 (= _base (- 1)))) +(let ((.def_221 (or .def_199 .def_220))) +(let ((.def_203 (not .def_199))) +(let ((.def_222 (and .def_203 .def_221))) +(let ((.def_147 (___z6z___ (- 1)))) +(let ((.def_223 (= .def_147 .def_222))) +.def_223 +)))))))))))))))) +(assert (let ((.def_224 (___z9z___ (- 1)))) +(let ((.def_225 (___z8z___ (- 1)))) +(let ((.def_226 (+ .def_224 .def_225))) +(let ((.def_228 (___z2z___ (- 1)))) +(let ((.def_227 (___z3z___ (- 1)))) +(let ((.def_229 (and .def_227 .def_228))) +(let ((.def_230 (ite .def_229 .def_226 .def_224))) +(let ((.def_192 (___z7z___ (- 1)))) +(let ((.def_231 (= .def_192 .def_230))) +.def_231 +)))))))))) +(assert (let ((.def_228 (___z2z___ (- 1)))) +(let ((.def_232 (not .def_228))) +(let ((.def_227 (___z3z___ (- 1)))) +(let ((.def_233 (and .def_227 .def_232))) +(let ((.def_234 (ite .def_233 2 0))) +(let ((.def_235 (not .def_227))) +(let ((.def_236 (and .def_228 .def_235))) +(let ((.def_237 (ite .def_236 1 .def_234))) +(let ((.def_225 (___z8z___ (- 1)))) +(let ((.def_238 (= .def_225 .def_237))) +.def_238 +))))))))))) +(assert (let ((.def_239 (___z7z___ (- 2)))) +(let ((.def_199 (= _base (- 1)))) +(let ((.def_240 (ite .def_199 0 .def_239))) +(let ((.def_224 (___z9z___ (- 1)))) +(let ((.def_241 (= .def_224 .def_240))) +.def_241 +)))))) +(push 1) +(assert (let ((.def_201 (___z4z___ (- 1)))) +(let ((.def_152 (___z4z___ 0))) +(let ((.def_242 (and .def_152 .def_201))) +(let ((.def_199 (= _base (- 1)))) +(let ((.def_203 (not .def_199))) +(let ((.def_243 (or .def_203 .def_242))) +(let ((.def_244 (not .def_243))) +.def_244 +)))))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_201 (___z4z___ (- 1)))) +.def_201 +)) +(assert (let ((.def_245 (___z4z___ (- 2)))) +.def_245 +)) +(push 1) +(assert (let ((.def_254 (___z4z___ _n))) +(let ((.def_252 (= _n _base))) +(let ((.def_248 (+ _n (- 1)))) +(let ((.def_249 (___z6z___ .def_248))) +(let ((.def_250 (not .def_249))) +(let ((.def_246 (___z5z___ _n))) +(let ((.def_247 (not .def_246))) +(let ((.def_251 (and .def_247 .def_250))) +(let ((.def_253 (or .def_251 .def_252))) +(let ((.def_255 (= .def_253 .def_254))) +.def_255 +))))))))))) +(assert (let ((.def_259 (___z7z___ _n))) +(let ((.def_263 (<= .def_259 (- 10)))) +(let ((.def_248 (+ _n (- 1)))) +(let ((.def_257 (___z5z___ .def_248))) +(let ((.def_264 (or .def_257 .def_263))) +(let ((.def_260 (<= 0 .def_259))) +(let ((.def_261 (not .def_260))) +(let ((.def_258 (not .def_257))) +(let ((.def_262 (or .def_258 .def_261))) +(let ((.def_265 (and .def_262 .def_264))) +(let ((.def_252 (= _n _base))) +(let ((.def_266 (or .def_252 .def_265))) +(let ((.def_256 (not .def_252))) +(let ((.def_267 (and .def_256 .def_266))) +(let ((.def_246 (___z5z___ _n))) +(let ((.def_268 (= .def_246 .def_267))) +.def_268 +))))))))))))))))) +(assert (let ((.def_277 (___z6z___ _n))) +(let ((.def_259 (___z7z___ _n))) +(let ((.def_272 (<= 10 .def_259))) +(let ((.def_248 (+ _n (- 1)))) +(let ((.def_249 (___z6z___ .def_248))) +(let ((.def_273 (or .def_249 .def_272))) +(let ((.def_269 (<= .def_259 0))) +(let ((.def_270 (not .def_269))) +(let ((.def_250 (not .def_249))) +(let ((.def_271 (or .def_250 .def_270))) +(let ((.def_274 (and .def_271 .def_273))) +(let ((.def_252 (= _n _base))) +(let ((.def_275 (or .def_252 .def_274))) +(let ((.def_256 (not .def_252))) +(let ((.def_276 (and .def_256 .def_275))) +(let ((.def_278 (= .def_276 .def_277))) +.def_278 +))))))))))))))))) +(assert (let ((.def_279 (___z9z___ _n))) +(let ((.def_280 (___z8z___ _n))) +(let ((.def_281 (+ .def_279 .def_280))) +(let ((.def_283 (___z2z___ _n))) +(let ((.def_282 (___z3z___ _n))) +(let ((.def_284 (and .def_282 .def_283))) +(let ((.def_285 (ite .def_284 .def_281 .def_279))) +(let ((.def_259 (___z7z___ _n))) +(let ((.def_286 (= .def_259 .def_285))) +.def_286 +)))))))))) +(assert (let ((.def_283 (___z2z___ _n))) +(let ((.def_287 (not .def_283))) +(let ((.def_282 (___z3z___ _n))) +(let ((.def_288 (and .def_282 .def_287))) +(let ((.def_289 (ite .def_288 2 0))) +(let ((.def_290 (not .def_282))) +(let ((.def_291 (and .def_283 .def_290))) +(let ((.def_292 (ite .def_291 1 .def_289))) +(let ((.def_280 (___z8z___ _n))) +(let ((.def_293 (= .def_280 .def_292))) +.def_293 +))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_252 (= _n _base))) +(let ((.def_295 (ite .def_252 0 .def_294))) +(let ((.def_279 (___z9z___ _n))) +(let ((.def_296 (= .def_279 .def_295))) +.def_296 +))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_305 (___z4z___ .def_248))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_298 (___z6z___ .def_297))) +(let ((.def_299 (not .def_298))) +(let ((.def_257 (___z5z___ .def_248))) +(let ((.def_258 (not .def_257))) +(let ((.def_300 (and .def_258 .def_299))) +(let ((.def_304 (or .def_300 .def_303))) +(let ((.def_306 (= .def_304 .def_305))) +.def_306 +)))))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_313 (<= .def_294 (- 10)))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_308 (___z5z___ .def_297))) +(let ((.def_314 (or .def_308 .def_313))) +(let ((.def_310 (<= 0 .def_294))) +(let ((.def_311 (not .def_310))) +(let ((.def_309 (not .def_308))) +(let ((.def_312 (or .def_309 .def_311))) +(let ((.def_315 (and .def_312 .def_314))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_316 (or .def_303 .def_315))) +(let ((.def_307 (not .def_303))) +(let ((.def_317 (and .def_307 .def_316))) +(let ((.def_257 (___z5z___ .def_248))) +(let ((.def_318 (= .def_257 .def_317))) +.def_318 +)))))))))))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_322 (<= 10 .def_294))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_298 (___z6z___ .def_297))) +(let ((.def_323 (or .def_298 .def_322))) +(let ((.def_319 (<= .def_294 0))) +(let ((.def_320 (not .def_319))) +(let ((.def_299 (not .def_298))) +(let ((.def_321 (or .def_299 .def_320))) +(let ((.def_324 (and .def_321 .def_323))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_325 (or .def_303 .def_324))) +(let ((.def_307 (not .def_303))) +(let ((.def_326 (and .def_307 .def_325))) +(let ((.def_249 (___z6z___ .def_248))) +(let ((.def_327 (= .def_249 .def_326))) +.def_327 +)))))))))))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_328 (___z9z___ .def_248))) +(let ((.def_329 (___z8z___ .def_248))) +(let ((.def_330 (+ .def_328 .def_329))) +(let ((.def_332 (___z2z___ .def_248))) +(let ((.def_331 (___z3z___ .def_248))) +(let ((.def_333 (and .def_331 .def_332))) +(let ((.def_334 (ite .def_333 .def_330 .def_328))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_335 (= .def_294 .def_334))) +.def_335 +))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_332 (___z2z___ .def_248))) +(let ((.def_336 (not .def_332))) +(let ((.def_331 (___z3z___ .def_248))) +(let ((.def_337 (and .def_331 .def_336))) +(let ((.def_338 (ite .def_337 2 0))) +(let ((.def_339 (not .def_331))) +(let ((.def_340 (and .def_332 .def_339))) +(let ((.def_341 (ite .def_340 1 .def_338))) +(let ((.def_329 (___z8z___ .def_248))) +(let ((.def_342 (= .def_329 .def_341))) +.def_342 +)))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_343 (___z7z___ .def_297))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_344 (ite .def_303 0 .def_343))) +(let ((.def_328 (___z9z___ .def_248))) +(let ((.def_345 (= .def_328 .def_344))) +.def_345 +)))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_305 (___z4z___ .def_248))) +.def_305 +))) +(assert (let ((.def_254 (___z4z___ _n))) +(let ((.def_199 (= _base (- 1)))) +(let ((.def_203 (not .def_199))) +(let ((.def_346 (or .def_203 .def_254))) +(let ((.def_347 (not .def_346))) +.def_347 +)))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_305 (___z4z___ .def_248))) +.def_305 +))) +(assert (let ((.def_348 (+ _n (- 2)))) +(let ((.def_349 (___z4z___ .def_348))) +.def_349 +))) +(assert (let ((.def_354 (= _base (- 2)))) +(let ((.def_351 (___z6z___ (- 3)))) +(let ((.def_352 (not .def_351))) +(let ((.def_204 (___z5z___ (- 2)))) +(let ((.def_205 (not .def_204))) +(let ((.def_353 (and .def_205 .def_352))) +(let ((.def_355 (or .def_353 .def_354))) +(let ((.def_245 (___z4z___ (- 2)))) +(let ((.def_356 (= .def_245 .def_355))) +.def_356 +)))))))))) +(assert (let ((.def_239 (___z7z___ (- 2)))) +(let ((.def_363 (<= .def_239 (- 10)))) +(let ((.def_358 (___z5z___ (- 3)))) +(let ((.def_364 (or .def_358 .def_363))) +(let ((.def_360 (<= 0 .def_239))) +(let ((.def_361 (not .def_360))) +(let ((.def_359 (not .def_358))) +(let ((.def_362 (or .def_359 .def_361))) +(let ((.def_365 (and .def_362 .def_364))) +(let ((.def_354 (= _base (- 2)))) +(let ((.def_366 (or .def_354 .def_365))) +(let ((.def_357 (not .def_354))) +(let ((.def_367 (and .def_357 .def_366))) +(let ((.def_204 (___z5z___ (- 2)))) +(let ((.def_368 (= .def_204 .def_367))) +.def_368 +)))))))))))))))) +(assert (let ((.def_239 (___z7z___ (- 2)))) +(let ((.def_372 (<= 10 .def_239))) +(let ((.def_351 (___z6z___ (- 3)))) +(let ((.def_373 (or .def_351 .def_372))) +(let ((.def_369 (<= .def_239 0))) +(let ((.def_370 (not .def_369))) +(let ((.def_352 (not .def_351))) +(let ((.def_371 (or .def_352 .def_370))) +(let ((.def_374 (and .def_371 .def_373))) +(let ((.def_354 (= _base (- 2)))) +(let ((.def_375 (or .def_354 .def_374))) +(let ((.def_357 (not .def_354))) +(let ((.def_376 (and .def_357 .def_375))) +(let ((.def_196 (___z6z___ (- 2)))) +(let ((.def_377 (= .def_196 .def_376))) +.def_377 +)))))))))))))))) +(assert (let ((.def_378 (___z9z___ (- 2)))) +(let ((.def_379 (___z8z___ (- 2)))) +(let ((.def_380 (+ .def_378 .def_379))) +(let ((.def_382 (___z2z___ (- 2)))) +(let ((.def_381 (___z3z___ (- 2)))) +(let ((.def_383 (and .def_381 .def_382))) +(let ((.def_384 (ite .def_383 .def_380 .def_378))) +(let ((.def_239 (___z7z___ (- 2)))) +(let ((.def_385 (= .def_239 .def_384))) +.def_385 +)))))))))) +(assert (let ((.def_382 (___z2z___ (- 2)))) +(let ((.def_386 (not .def_382))) +(let ((.def_381 (___z3z___ (- 2)))) +(let ((.def_387 (and .def_381 .def_386))) +(let ((.def_388 (ite .def_387 2 0))) +(let ((.def_389 (not .def_381))) +(let ((.def_390 (and .def_382 .def_389))) +(let ((.def_391 (ite .def_390 1 .def_388))) +(let ((.def_379 (___z8z___ (- 2)))) +(let ((.def_392 (= .def_379 .def_391))) +.def_392 +))))))))))) +(assert (let ((.def_393 (___z7z___ (- 3)))) +(let ((.def_354 (= _base (- 2)))) +(let ((.def_394 (ite .def_354 0 .def_393))) +(let ((.def_378 (___z9z___ (- 2)))) +(let ((.def_395 (= .def_378 .def_394))) +.def_395 +)))))) +(assert (let ((.def_254 (___z4z___ _n))) +(let ((.def_252 (= _n _base))) +(let ((.def_248 (+ _n (- 1)))) +(let ((.def_249 (___z6z___ .def_248))) +(let ((.def_250 (not .def_249))) +(let ((.def_246 (___z5z___ _n))) +(let ((.def_247 (not .def_246))) +(let ((.def_251 (and .def_247 .def_250))) +(let ((.def_253 (or .def_251 .def_252))) +(let ((.def_255 (= .def_253 .def_254))) +.def_255 +))))))))))) +(assert (let ((.def_259 (___z7z___ _n))) +(let ((.def_263 (<= .def_259 (- 10)))) +(let ((.def_248 (+ _n (- 1)))) +(let ((.def_257 (___z5z___ .def_248))) +(let ((.def_264 (or .def_257 .def_263))) +(let ((.def_260 (<= 0 .def_259))) +(let ((.def_261 (not .def_260))) +(let ((.def_258 (not .def_257))) +(let ((.def_262 (or .def_258 .def_261))) +(let ((.def_265 (and .def_262 .def_264))) +(let ((.def_252 (= _n _base))) +(let ((.def_266 (or .def_252 .def_265))) +(let ((.def_256 (not .def_252))) +(let ((.def_267 (and .def_256 .def_266))) +(let ((.def_246 (___z5z___ _n))) +(let ((.def_268 (= .def_246 .def_267))) +.def_268 +))))))))))))))))) +(assert (let ((.def_277 (___z6z___ _n))) +(let ((.def_259 (___z7z___ _n))) +(let ((.def_272 (<= 10 .def_259))) +(let ((.def_248 (+ _n (- 1)))) +(let ((.def_249 (___z6z___ .def_248))) +(let ((.def_273 (or .def_249 .def_272))) +(let ((.def_269 (<= .def_259 0))) +(let ((.def_270 (not .def_269))) +(let ((.def_250 (not .def_249))) +(let ((.def_271 (or .def_250 .def_270))) +(let ((.def_274 (and .def_271 .def_273))) +(let ((.def_252 (= _n _base))) +(let ((.def_275 (or .def_252 .def_274))) +(let ((.def_256 (not .def_252))) +(let ((.def_276 (and .def_256 .def_275))) +(let ((.def_278 (= .def_276 .def_277))) +.def_278 +))))))))))))))))) +(assert (let ((.def_279 (___z9z___ _n))) +(let ((.def_280 (___z8z___ _n))) +(let ((.def_281 (+ .def_279 .def_280))) +(let ((.def_283 (___z2z___ _n))) +(let ((.def_282 (___z3z___ _n))) +(let ((.def_284 (and .def_282 .def_283))) +(let ((.def_285 (ite .def_284 .def_281 .def_279))) +(let ((.def_259 (___z7z___ _n))) +(let ((.def_286 (= .def_259 .def_285))) +.def_286 +)))))))))) +(assert (let ((.def_283 (___z2z___ _n))) +(let ((.def_287 (not .def_283))) +(let ((.def_282 (___z3z___ _n))) +(let ((.def_288 (and .def_282 .def_287))) +(let ((.def_289 (ite .def_288 2 0))) +(let ((.def_290 (not .def_282))) +(let ((.def_291 (and .def_283 .def_290))) +(let ((.def_292 (ite .def_291 1 .def_289))) +(let ((.def_280 (___z8z___ _n))) +(let ((.def_293 (= .def_280 .def_292))) +.def_293 +))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_252 (= _n _base))) +(let ((.def_295 (ite .def_252 0 .def_294))) +(let ((.def_279 (___z9z___ _n))) +(let ((.def_296 (= .def_279 .def_295))) +.def_296 +))))))) +(push 1) +(assert (let ((.def_354 (= _base (- 2)))) +(let ((.def_357 (not .def_354))) +(let ((.def_152 (___z4z___ 0))) +(let ((.def_396 (or .def_152 .def_357))) +(let ((.def_397 (not .def_396))) +.def_397 +)))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_399 (___z4z___ (- 3)))) +.def_399 +)) +(push 1) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_305 (___z4z___ .def_248))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_298 (___z6z___ .def_297))) +(let ((.def_299 (not .def_298))) +(let ((.def_257 (___z5z___ .def_248))) +(let ((.def_258 (not .def_257))) +(let ((.def_300 (and .def_258 .def_299))) +(let ((.def_304 (or .def_300 .def_303))) +(let ((.def_306 (= .def_304 .def_305))) +.def_306 +)))))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_313 (<= .def_294 (- 10)))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_308 (___z5z___ .def_297))) +(let ((.def_314 (or .def_308 .def_313))) +(let ((.def_310 (<= 0 .def_294))) +(let ((.def_311 (not .def_310))) +(let ((.def_309 (not .def_308))) +(let ((.def_312 (or .def_309 .def_311))) +(let ((.def_315 (and .def_312 .def_314))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_316 (or .def_303 .def_315))) +(let ((.def_307 (not .def_303))) +(let ((.def_317 (and .def_307 .def_316))) +(let ((.def_257 (___z5z___ .def_248))) +(let ((.def_318 (= .def_257 .def_317))) +.def_318 +)))))))))))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_322 (<= 10 .def_294))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_298 (___z6z___ .def_297))) +(let ((.def_323 (or .def_298 .def_322))) +(let ((.def_319 (<= .def_294 0))) +(let ((.def_320 (not .def_319))) +(let ((.def_299 (not .def_298))) +(let ((.def_321 (or .def_299 .def_320))) +(let ((.def_324 (and .def_321 .def_323))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_325 (or .def_303 .def_324))) +(let ((.def_307 (not .def_303))) +(let ((.def_326 (and .def_307 .def_325))) +(let ((.def_249 (___z6z___ .def_248))) +(let ((.def_327 (= .def_249 .def_326))) +.def_327 +)))))))))))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_328 (___z9z___ .def_248))) +(let ((.def_329 (___z8z___ .def_248))) +(let ((.def_330 (+ .def_328 .def_329))) +(let ((.def_332 (___z2z___ .def_248))) +(let ((.def_331 (___z3z___ .def_248))) +(let ((.def_333 (and .def_331 .def_332))) +(let ((.def_334 (ite .def_333 .def_330 .def_328))) +(let ((.def_294 (___z7z___ .def_248))) +(let ((.def_335 (= .def_294 .def_334))) +.def_335 +))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_332 (___z2z___ .def_248))) +(let ((.def_336 (not .def_332))) +(let ((.def_331 (___z3z___ .def_248))) +(let ((.def_337 (and .def_331 .def_336))) +(let ((.def_338 (ite .def_337 2 0))) +(let ((.def_339 (not .def_331))) +(let ((.def_340 (and .def_332 .def_339))) +(let ((.def_341 (ite .def_340 1 .def_338))) +(let ((.def_329 (___z8z___ .def_248))) +(let ((.def_342 (= .def_329 .def_341))) +.def_342 +)))))))))))) +(assert (let ((.def_248 (+ _n (- 1)))) +(let ((.def_297 (+ (- 1) .def_248))) +(let ((.def_343 (___z7z___ .def_297))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_303 (= .def_302 1))) +(let ((.def_344 (ite .def_303 0 .def_343))) +(let ((.def_328 (___z9z___ .def_248))) +(let ((.def_345 (= .def_328 .def_344))) +.def_345 +)))))))))) +(assert (let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_406 (= .def_302 2))) +(let ((.def_348 (+ _n (- 2)))) +(let ((.def_402 (+ (- 1) .def_348))) +(let ((.def_403 (___z6z___ .def_402))) +(let ((.def_404 (not .def_403))) +(let ((.def_400 (___z5z___ .def_348))) +(let ((.def_401 (not .def_400))) +(let ((.def_405 (and .def_401 .def_404))) +(let ((.def_407 (or .def_405 .def_406))) +(let ((.def_349 (___z4z___ .def_348))) +(let ((.def_408 (= .def_349 .def_407))) +.def_408 +)))))))))))))) +(assert (let ((.def_348 (+ _n (- 2)))) +(let ((.def_412 (___z7z___ .def_348))) +(let ((.def_416 (<= .def_412 (- 10)))) +(let ((.def_402 (+ (- 1) .def_348))) +(let ((.def_410 (___z5z___ .def_402))) +(let ((.def_417 (or .def_410 .def_416))) +(let ((.def_413 (<= 0 .def_412))) +(let ((.def_414 (not .def_413))) +(let ((.def_411 (not .def_410))) +(let ((.def_415 (or .def_411 .def_414))) +(let ((.def_418 (and .def_415 .def_417))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_406 (= .def_302 2))) +(let ((.def_419 (or .def_406 .def_418))) +(let ((.def_409 (not .def_406))) +(let ((.def_420 (and .def_409 .def_419))) +(let ((.def_400 (___z5z___ .def_348))) +(let ((.def_421 (= .def_400 .def_420))) +.def_421 +)))))))))))))))))))) +(assert (let ((.def_348 (+ _n (- 2)))) +(let ((.def_430 (___z6z___ .def_348))) +(let ((.def_412 (___z7z___ .def_348))) +(let ((.def_425 (<= 10 .def_412))) +(let ((.def_402 (+ (- 1) .def_348))) +(let ((.def_403 (___z6z___ .def_402))) +(let ((.def_426 (or .def_403 .def_425))) +(let ((.def_422 (<= .def_412 0))) +(let ((.def_423 (not .def_422))) +(let ((.def_404 (not .def_403))) +(let ((.def_424 (or .def_404 .def_423))) +(let ((.def_427 (and .def_424 .def_426))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_406 (= .def_302 2))) +(let ((.def_428 (or .def_406 .def_427))) +(let ((.def_409 (not .def_406))) +(let ((.def_429 (and .def_409 .def_428))) +(let ((.def_431 (= .def_429 .def_430))) +.def_431 +)))))))))))))))))))) +(assert (let ((.def_348 (+ _n (- 2)))) +(let ((.def_432 (___z9z___ .def_348))) +(let ((.def_433 (___z8z___ .def_348))) +(let ((.def_434 (+ .def_432 .def_433))) +(let ((.def_436 (___z2z___ .def_348))) +(let ((.def_435 (___z3z___ .def_348))) +(let ((.def_437 (and .def_435 .def_436))) +(let ((.def_438 (ite .def_437 .def_434 .def_432))) +(let ((.def_412 (___z7z___ .def_348))) +(let ((.def_439 (= .def_412 .def_438))) +.def_439 +))))))))))) +(assert (let ((.def_348 (+ _n (- 2)))) +(let ((.def_436 (___z2z___ .def_348))) +(let ((.def_440 (not .def_436))) +(let ((.def_435 (___z3z___ .def_348))) +(let ((.def_441 (and .def_435 .def_440))) +(let ((.def_442 (ite .def_441 2 0))) +(let ((.def_443 (not .def_435))) +(let ((.def_444 (and .def_436 .def_443))) +(let ((.def_445 (ite .def_444 1 .def_442))) +(let ((.def_433 (___z8z___ .def_348))) +(let ((.def_446 (= .def_433 .def_445))) +.def_446 +)))))))))))) +(assert (let ((.def_348 (+ _n (- 2)))) +(let ((.def_402 (+ (- 1) .def_348))) +(let ((.def_447 (___z7z___ .def_402))) +(let ((.def_301 (* (- 1) _base))) +(let ((.def_302 (+ _n .def_301))) +(let ((.def_406 (= .def_302 2))) +(let ((.def_448 (ite .def_406 0 .def_447))) +(let ((.def_432 (___z9z___ .def_348))) +(let ((.def_449 (= .def_432 .def_448))) +.def_449 +)))))))))) +(assert (let ((.def_354 (= _base (- 2)))) +(let ((.def_357 (not .def_354))) +(let ((.def_254 (___z4z___ _n))) +(let ((.def_450 (or .def_254 .def_357))) +(let ((.def_451 (not .def_450))) +.def_451 +)))))) +(assert true +) +(check-sat) diff --git a/test/regress/regress1/uflia/speed2_e8_449_e8_517.ec.smt2.expect b/test/regress/regress1/uflia/speed2_e8_449_e8_517.ec.smt2.expect new file mode 100644 index 000000000..65fb9b33f --- /dev/null +++ b/test/regress/regress1/uflia/speed2_e8_449_e8_517.ec.smt2.expect @@ -0,0 +1,5 @@ +% COMMAND-LINE: --incremental +% EXPECT: unsat +% EXPECT: sat +% EXPECT: unsat +% EXPECT: unsat diff --git a/test/regress/regress1/uflia/stalmark_e7_27_e7_31.ec.smt2 b/test/regress/regress1/uflia/stalmark_e7_27_e7_31.ec.smt2 new file mode 100644 index 000000000..381eb740b --- /dev/null +++ b/test/regress/regress1/uflia/stalmark_e7_27_e7_31.ec.smt2 @@ -0,0 +1,772 @@ +(set-logic QF_UFLIA) +(declare-fun _base () Int) +(declare-fun _n () Int) +(assert (let ((.def_5 (<= 0 _n))) +.def_5 +)) +(declare-fun ___z3z___ (Int) Bool) +(declare-fun ___z4z___ (Int) Bool) +(declare-fun ___z5z___ (Int) Bool) +(declare-fun ___z6z___ (Int) Bool) +(push 1) +(assert (let ((.def_117 (___z3z___ 0))) +(let ((.def_99 (___z4z___ 0))) +(let ((.def_108 (not .def_99))) +(let ((.def_98 (___z5z___ 0))) +(let ((.def_104 (not .def_98))) +(let ((.def_111 (or .def_104 .def_108))) +(let ((.def_101 (___z6z___ 0))) +(let ((.def_112 (or .def_101 .def_111))) +(let ((.def_109 (and .def_98 .def_108))) +(let ((.def_106 (not .def_101))) +(let ((.def_110 (and .def_106 .def_109))) +(let ((.def_113 (or .def_110 .def_112))) +(let ((.def_105 (and .def_99 .def_104))) +(let ((.def_107 (and .def_105 .def_106))) +(let ((.def_114 (or .def_107 .def_113))) +(let ((.def_100 (and .def_98 .def_99))) +(let ((.def_102 (and .def_100 .def_101))) +(let ((.def_115 (or .def_102 .def_114))) +(let ((.def_103 (not .def_102))) +(let ((.def_116 (and .def_103 .def_115))) +(let ((.def_118 (= .def_116 .def_117))) +.def_118 +)))))))))))))))))))))) +(assert (let ((.def_120 (= _base 0))) +(let ((.def_119 (___z6z___ (- 1)))) +(let ((.def_121 (or .def_119 .def_120))) +(let ((.def_99 (___z4z___ 0))) +(let ((.def_122 (= .def_99 .def_121))) +.def_122 +)))))) +(assert (let ((.def_124 (___z4z___ (- 1)))) +(let ((.def_120 (= _base 0))) +(let ((.def_125 (or .def_120 .def_124))) +(let ((.def_123 (not .def_120))) +(let ((.def_126 (and .def_123 .def_125))) +(let ((.def_98 (___z5z___ 0))) +(let ((.def_127 (= .def_98 .def_126))) +.def_127 +)))))))) +(assert (let ((.def_128 (___z5z___ (- 1)))) +(let ((.def_120 (= _base 0))) +(let ((.def_129 (or .def_120 .def_128))) +(let ((.def_123 (not .def_120))) +(let ((.def_130 (and .def_123 .def_129))) +(let ((.def_101 (___z6z___ 0))) +(let ((.def_131 (= .def_101 .def_130))) +.def_131 +)))))))) +(assert (let ((.def_148 (___z3z___ (- 1)))) +(let ((.def_124 (___z4z___ (- 1)))) +(let ((.def_139 (not .def_124))) +(let ((.def_128 (___z5z___ (- 1)))) +(let ((.def_135 (not .def_128))) +(let ((.def_142 (or .def_135 .def_139))) +(let ((.def_119 (___z6z___ (- 1)))) +(let ((.def_143 (or .def_119 .def_142))) +(let ((.def_140 (and .def_128 .def_139))) +(let ((.def_137 (not .def_119))) +(let ((.def_141 (and .def_137 .def_140))) +(let ((.def_144 (or .def_141 .def_143))) +(let ((.def_136 (and .def_124 .def_135))) +(let ((.def_138 (and .def_136 .def_137))) +(let ((.def_145 (or .def_138 .def_144))) +(let ((.def_132 (and .def_124 .def_128))) +(let ((.def_133 (and .def_119 .def_132))) +(let ((.def_146 (or .def_133 .def_145))) +(let ((.def_134 (not .def_133))) +(let ((.def_147 (and .def_134 .def_146))) +(let ((.def_149 (= .def_147 .def_148))) +.def_149 +)))))))))))))))))))))) +(assert (let ((.def_152 (= _base (- 1)))) +(let ((.def_151 (___z6z___ (- 2)))) +(let ((.def_153 (or .def_151 .def_152))) +(let ((.def_124 (___z4z___ (- 1)))) +(let ((.def_154 (= .def_124 .def_153))) +.def_154 +)))))) +(assert (let ((.def_156 (___z4z___ (- 2)))) +(let ((.def_152 (= _base (- 1)))) +(let ((.def_157 (or .def_152 .def_156))) +(let ((.def_155 (not .def_152))) +(let ((.def_158 (and .def_155 .def_157))) +(let ((.def_128 (___z5z___ (- 1)))) +(let ((.def_159 (= .def_128 .def_158))) +.def_159 +)))))))) +(assert (let ((.def_160 (___z5z___ (- 2)))) +(let ((.def_152 (= _base (- 1)))) +(let ((.def_161 (or .def_152 .def_160))) +(let ((.def_155 (not .def_152))) +(let ((.def_162 (and .def_155 .def_161))) +(let ((.def_119 (___z6z___ (- 1)))) +(let ((.def_163 (= .def_119 .def_162))) +.def_163 +)))))))) +(push 1) +(assert (let ((.def_148 (___z3z___ (- 1)))) +(let ((.def_117 (___z3z___ 0))) +(let ((.def_164 (and .def_117 .def_148))) +(let ((.def_152 (= _base (- 1)))) +(let ((.def_155 (not .def_152))) +(let ((.def_165 (or .def_155 .def_164))) +(let ((.def_166 (not .def_165))) +.def_166 +)))))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_148 (___z3z___ (- 1)))) +.def_148 +)) +(assert (let ((.def_168 (___z3z___ (- 2)))) +.def_168 +)) +(push 1) +(assert (let ((.def_188 (___z3z___ _n))) +(let ((.def_170 (___z4z___ _n))) +(let ((.def_179 (not .def_170))) +(let ((.def_169 (___z5z___ _n))) +(let ((.def_175 (not .def_169))) +(let ((.def_182 (or .def_175 .def_179))) +(let ((.def_172 (___z6z___ _n))) +(let ((.def_183 (or .def_172 .def_182))) +(let ((.def_180 (and .def_169 .def_179))) +(let ((.def_177 (not .def_172))) +(let ((.def_181 (and .def_177 .def_180))) +(let ((.def_184 (or .def_181 .def_183))) +(let ((.def_176 (and .def_170 .def_175))) +(let ((.def_178 (and .def_176 .def_177))) +(let ((.def_185 (or .def_178 .def_184))) +(let ((.def_171 (and .def_169 .def_170))) +(let ((.def_173 (and .def_171 .def_172))) +(let ((.def_186 (or .def_173 .def_185))) +(let ((.def_174 (not .def_173))) +(let ((.def_187 (and .def_174 .def_186))) +(let ((.def_189 (= .def_187 .def_188))) +.def_189 +)))))))))))))))))))))) +(assert (let ((.def_192 (= _n _base))) +(let ((.def_190 (+ _n (- 1)))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_193 (or .def_191 .def_192))) +(let ((.def_170 (___z4z___ _n))) +(let ((.def_194 (= .def_170 .def_193))) +.def_194 +))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_192 (= _n _base))) +(let ((.def_197 (or .def_192 .def_196))) +(let ((.def_195 (not .def_192))) +(let ((.def_198 (and .def_195 .def_197))) +(let ((.def_169 (___z5z___ _n))) +(let ((.def_199 (= .def_169 .def_198))) +.def_199 +))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_192 (= _n _base))) +(let ((.def_201 (or .def_192 .def_200))) +(let ((.def_195 (not .def_192))) +(let ((.def_202 (and .def_195 .def_201))) +(let ((.def_172 (___z6z___ _n))) +(let ((.def_203 (= .def_172 .def_202))) +.def_203 +))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_220 (___z3z___ .def_190))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_211 (not .def_196))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_207 (not .def_200))) +(let ((.def_214 (or .def_207 .def_211))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_215 (or .def_191 .def_214))) +(let ((.def_212 (and .def_200 .def_211))) +(let ((.def_209 (not .def_191))) +(let ((.def_213 (and .def_209 .def_212))) +(let ((.def_216 (or .def_213 .def_215))) +(let ((.def_208 (and .def_196 .def_207))) +(let ((.def_210 (and .def_208 .def_209))) +(let ((.def_217 (or .def_210 .def_216))) +(let ((.def_204 (and .def_196 .def_200))) +(let ((.def_205 (and .def_191 .def_204))) +(let ((.def_218 (or .def_205 .def_217))) +(let ((.def_206 (not .def_205))) +(let ((.def_219 (and .def_206 .def_218))) +(let ((.def_221 (= .def_219 .def_220))) +.def_221 +))))))))))))))))))))))) +(assert (let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_223 (___z6z___ .def_222))) +(let ((.def_227 (or .def_223 .def_226))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_228 (= .def_196 .def_227))) +.def_228 +)))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_230 (___z4z___ .def_222))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_231 (or .def_226 .def_230))) +(let ((.def_229 (not .def_226))) +(let ((.def_232 (and .def_229 .def_231))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_233 (= .def_200 .def_232))) +.def_233 +)))))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_234 (___z5z___ .def_222))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_235 (or .def_226 .def_234))) +(let ((.def_229 (not .def_226))) +(let ((.def_236 (and .def_229 .def_235))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_237 (= .def_191 .def_236))) +.def_237 +)))))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_220 (___z3z___ .def_190))) +.def_220 +))) +(assert (let ((.def_188 (___z3z___ _n))) +(let ((.def_152 (= _base (- 1)))) +(let ((.def_155 (not .def_152))) +(let ((.def_238 (or .def_155 .def_188))) +(let ((.def_239 (not .def_238))) +.def_239 +)))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_220 (___z3z___ .def_190))) +.def_220 +))) +(assert (let ((.def_240 (+ _n (- 2)))) +(let ((.def_241 (___z3z___ .def_240))) +.def_241 +))) +(assert (let ((.def_156 (___z4z___ (- 2)))) +(let ((.def_249 (not .def_156))) +(let ((.def_160 (___z5z___ (- 2)))) +(let ((.def_245 (not .def_160))) +(let ((.def_252 (or .def_245 .def_249))) +(let ((.def_151 (___z6z___ (- 2)))) +(let ((.def_253 (or .def_151 .def_252))) +(let ((.def_250 (and .def_160 .def_249))) +(let ((.def_247 (not .def_151))) +(let ((.def_251 (and .def_247 .def_250))) +(let ((.def_254 (or .def_251 .def_253))) +(let ((.def_246 (and .def_156 .def_245))) +(let ((.def_248 (and .def_246 .def_247))) +(let ((.def_255 (or .def_248 .def_254))) +(let ((.def_242 (and .def_156 .def_160))) +(let ((.def_243 (and .def_151 .def_242))) +(let ((.def_256 (or .def_243 .def_255))) +(let ((.def_244 (not .def_243))) +(let ((.def_257 (and .def_244 .def_256))) +(let ((.def_168 (___z3z___ (- 2)))) +(let ((.def_258 (= .def_168 .def_257))) +.def_258 +)))))))))))))))))))))) +(assert (let ((.def_261 (= _base (- 2)))) +(let ((.def_260 (___z6z___ (- 3)))) +(let ((.def_262 (or .def_260 .def_261))) +(let ((.def_156 (___z4z___ (- 2)))) +(let ((.def_263 (= .def_156 .def_262))) +.def_263 +)))))) +(assert (let ((.def_265 (___z4z___ (- 3)))) +(let ((.def_261 (= _base (- 2)))) +(let ((.def_266 (or .def_261 .def_265))) +(let ((.def_264 (not .def_261))) +(let ((.def_267 (and .def_264 .def_266))) +(let ((.def_160 (___z5z___ (- 2)))) +(let ((.def_268 (= .def_160 .def_267))) +.def_268 +)))))))) +(assert (let ((.def_269 (___z5z___ (- 3)))) +(let ((.def_261 (= _base (- 2)))) +(let ((.def_270 (or .def_261 .def_269))) +(let ((.def_264 (not .def_261))) +(let ((.def_271 (and .def_264 .def_270))) +(let ((.def_151 (___z6z___ (- 2)))) +(let ((.def_272 (= .def_151 .def_271))) +.def_272 +)))))))) +(assert (let ((.def_188 (___z3z___ _n))) +(let ((.def_170 (___z4z___ _n))) +(let ((.def_179 (not .def_170))) +(let ((.def_169 (___z5z___ _n))) +(let ((.def_175 (not .def_169))) +(let ((.def_182 (or .def_175 .def_179))) +(let ((.def_172 (___z6z___ _n))) +(let ((.def_183 (or .def_172 .def_182))) +(let ((.def_180 (and .def_169 .def_179))) +(let ((.def_177 (not .def_172))) +(let ((.def_181 (and .def_177 .def_180))) +(let ((.def_184 (or .def_181 .def_183))) +(let ((.def_176 (and .def_170 .def_175))) +(let ((.def_178 (and .def_176 .def_177))) +(let ((.def_185 (or .def_178 .def_184))) +(let ((.def_171 (and .def_169 .def_170))) +(let ((.def_173 (and .def_171 .def_172))) +(let ((.def_186 (or .def_173 .def_185))) +(let ((.def_174 (not .def_173))) +(let ((.def_187 (and .def_174 .def_186))) +(let ((.def_189 (= .def_187 .def_188))) +.def_189 +)))))))))))))))))))))) +(assert (let ((.def_192 (= _n _base))) +(let ((.def_190 (+ _n (- 1)))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_193 (or .def_191 .def_192))) +(let ((.def_170 (___z4z___ _n))) +(let ((.def_194 (= .def_170 .def_193))) +.def_194 +))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_192 (= _n _base))) +(let ((.def_197 (or .def_192 .def_196))) +(let ((.def_195 (not .def_192))) +(let ((.def_198 (and .def_195 .def_197))) +(let ((.def_169 (___z5z___ _n))) +(let ((.def_199 (= .def_169 .def_198))) +.def_199 +))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_192 (= _n _base))) +(let ((.def_201 (or .def_192 .def_200))) +(let ((.def_195 (not .def_192))) +(let ((.def_202 (and .def_195 .def_201))) +(let ((.def_172 (___z6z___ _n))) +(let ((.def_203 (= .def_172 .def_202))) +.def_203 +))))))))) +(push 1) +(assert (let ((.def_261 (= _base (- 2)))) +(let ((.def_264 (not .def_261))) +(let ((.def_117 (___z3z___ 0))) +(let ((.def_273 (or .def_117 .def_264))) +(let ((.def_274 (not .def_273))) +.def_274 +)))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_276 (___z3z___ (- 3)))) +.def_276 +)) +(push 1) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_220 (___z3z___ .def_190))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_211 (not .def_196))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_207 (not .def_200))) +(let ((.def_214 (or .def_207 .def_211))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_215 (or .def_191 .def_214))) +(let ((.def_212 (and .def_200 .def_211))) +(let ((.def_209 (not .def_191))) +(let ((.def_213 (and .def_209 .def_212))) +(let ((.def_216 (or .def_213 .def_215))) +(let ((.def_208 (and .def_196 .def_207))) +(let ((.def_210 (and .def_208 .def_209))) +(let ((.def_217 (or .def_210 .def_216))) +(let ((.def_204 (and .def_196 .def_200))) +(let ((.def_205 (and .def_191 .def_204))) +(let ((.def_218 (or .def_205 .def_217))) +(let ((.def_206 (not .def_205))) +(let ((.def_219 (and .def_206 .def_218))) +(let ((.def_221 (= .def_219 .def_220))) +.def_221 +))))))))))))))))))))))) +(assert (let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_223 (___z6z___ .def_222))) +(let ((.def_227 (or .def_223 .def_226))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_228 (= .def_196 .def_227))) +.def_228 +)))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_230 (___z4z___ .def_222))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_231 (or .def_226 .def_230))) +(let ((.def_229 (not .def_226))) +(let ((.def_232 (and .def_229 .def_231))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_233 (= .def_200 .def_232))) +.def_233 +)))))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_234 (___z5z___ .def_222))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_235 (or .def_226 .def_234))) +(let ((.def_229 (not .def_226))) +(let ((.def_236 (and .def_229 .def_235))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_237 (= .def_191 .def_236))) +.def_237 +)))))))))))) +(assert (let ((.def_240 (+ _n (- 2)))) +(let ((.def_278 (___z4z___ .def_240))) +(let ((.def_287 (not .def_278))) +(let ((.def_277 (___z5z___ .def_240))) +(let ((.def_283 (not .def_277))) +(let ((.def_290 (or .def_283 .def_287))) +(let ((.def_280 (___z6z___ .def_240))) +(let ((.def_291 (or .def_280 .def_290))) +(let ((.def_288 (and .def_277 .def_287))) +(let ((.def_285 (not .def_280))) +(let ((.def_289 (and .def_285 .def_288))) +(let ((.def_292 (or .def_289 .def_291))) +(let ((.def_284 (and .def_278 .def_283))) +(let ((.def_286 (and .def_284 .def_285))) +(let ((.def_293 (or .def_286 .def_292))) +(let ((.def_279 (and .def_277 .def_278))) +(let ((.def_281 (and .def_279 .def_280))) +(let ((.def_294 (or .def_281 .def_293))) +(let ((.def_282 (not .def_281))) +(let ((.def_295 (and .def_282 .def_294))) +(let ((.def_241 (___z3z___ .def_240))) +(let ((.def_296 (= .def_241 .def_295))) +.def_296 +))))))))))))))))))))))) +(assert (let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_299 (= .def_225 2))) +(let ((.def_240 (+ _n (- 2)))) +(let ((.def_297 (+ (- 1) .def_240))) +(let ((.def_298 (___z6z___ .def_297))) +(let ((.def_300 (or .def_298 .def_299))) +(let ((.def_278 (___z4z___ .def_240))) +(let ((.def_301 (= .def_278 .def_300))) +.def_301 +)))))))))) +(assert (let ((.def_240 (+ _n (- 2)))) +(let ((.def_297 (+ (- 1) .def_240))) +(let ((.def_303 (___z4z___ .def_297))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_299 (= .def_225 2))) +(let ((.def_304 (or .def_299 .def_303))) +(let ((.def_302 (not .def_299))) +(let ((.def_305 (and .def_302 .def_304))) +(let ((.def_277 (___z5z___ .def_240))) +(let ((.def_306 (= .def_277 .def_305))) +.def_306 +)))))))))))) +(assert (let ((.def_240 (+ _n (- 2)))) +(let ((.def_297 (+ (- 1) .def_240))) +(let ((.def_307 (___z5z___ .def_297))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_299 (= .def_225 2))) +(let ((.def_308 (or .def_299 .def_307))) +(let ((.def_302 (not .def_299))) +(let ((.def_309 (and .def_302 .def_308))) +(let ((.def_280 (___z6z___ .def_240))) +(let ((.def_310 (= .def_280 .def_309))) +.def_310 +)))))))))))) +(assert (let ((.def_261 (= _base (- 2)))) +(let ((.def_264 (not .def_261))) +(let ((.def_188 (___z3z___ _n))) +(let ((.def_311 (or .def_188 .def_264))) +(let ((.def_312 (not .def_311))) +.def_312 +)))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_313 (+ _n (- 3)))) +(let ((.def_314 (___z3z___ .def_313))) +.def_314 +))) +(assert (let ((.def_265 (___z4z___ (- 3)))) +(let ((.def_322 (not .def_265))) +(let ((.def_269 (___z5z___ (- 3)))) +(let ((.def_318 (not .def_269))) +(let ((.def_325 (or .def_318 .def_322))) +(let ((.def_260 (___z6z___ (- 3)))) +(let ((.def_326 (or .def_260 .def_325))) +(let ((.def_323 (and .def_269 .def_322))) +(let ((.def_320 (not .def_260))) +(let ((.def_324 (and .def_320 .def_323))) +(let ((.def_327 (or .def_324 .def_326))) +(let ((.def_319 (and .def_265 .def_318))) +(let ((.def_321 (and .def_319 .def_320))) +(let ((.def_328 (or .def_321 .def_327))) +(let ((.def_315 (and .def_265 .def_269))) +(let ((.def_316 (and .def_260 .def_315))) +(let ((.def_329 (or .def_316 .def_328))) +(let ((.def_317 (not .def_316))) +(let ((.def_330 (and .def_317 .def_329))) +(let ((.def_276 (___z3z___ (- 3)))) +(let ((.def_331 (= .def_276 .def_330))) +.def_331 +)))))))))))))))))))))) +(assert (let ((.def_334 (= _base (- 3)))) +(let ((.def_333 (___z6z___ (- 4)))) +(let ((.def_335 (or .def_333 .def_334))) +(let ((.def_265 (___z4z___ (- 3)))) +(let ((.def_336 (= .def_265 .def_335))) +.def_336 +)))))) +(assert (let ((.def_338 (___z4z___ (- 4)))) +(let ((.def_334 (= _base (- 3)))) +(let ((.def_339 (or .def_334 .def_338))) +(let ((.def_337 (not .def_334))) +(let ((.def_340 (and .def_337 .def_339))) +(let ((.def_269 (___z5z___ (- 3)))) +(let ((.def_341 (= .def_269 .def_340))) +.def_341 +)))))))) +(assert (let ((.def_342 (___z5z___ (- 4)))) +(let ((.def_334 (= _base (- 3)))) +(let ((.def_343 (or .def_334 .def_342))) +(let ((.def_337 (not .def_334))) +(let ((.def_344 (and .def_337 .def_343))) +(let ((.def_260 (___z6z___ (- 3)))) +(let ((.def_345 (= .def_260 .def_344))) +.def_345 +)))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_220 (___z3z___ .def_190))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_211 (not .def_196))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_207 (not .def_200))) +(let ((.def_214 (or .def_207 .def_211))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_215 (or .def_191 .def_214))) +(let ((.def_212 (and .def_200 .def_211))) +(let ((.def_209 (not .def_191))) +(let ((.def_213 (and .def_209 .def_212))) +(let ((.def_216 (or .def_213 .def_215))) +(let ((.def_208 (and .def_196 .def_207))) +(let ((.def_210 (and .def_208 .def_209))) +(let ((.def_217 (or .def_210 .def_216))) +(let ((.def_204 (and .def_196 .def_200))) +(let ((.def_205 (and .def_191 .def_204))) +(let ((.def_218 (or .def_205 .def_217))) +(let ((.def_206 (not .def_205))) +(let ((.def_219 (and .def_206 .def_218))) +(let ((.def_221 (= .def_219 .def_220))) +.def_221 +))))))))))))))))))))))) +(assert (let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_223 (___z6z___ .def_222))) +(let ((.def_227 (or .def_223 .def_226))) +(let ((.def_196 (___z4z___ .def_190))) +(let ((.def_228 (= .def_196 .def_227))) +.def_228 +)))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_230 (___z4z___ .def_222))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_231 (or .def_226 .def_230))) +(let ((.def_229 (not .def_226))) +(let ((.def_232 (and .def_229 .def_231))) +(let ((.def_200 (___z5z___ .def_190))) +(let ((.def_233 (= .def_200 .def_232))) +.def_233 +)))))))))))) +(assert (let ((.def_190 (+ _n (- 1)))) +(let ((.def_222 (+ (- 1) .def_190))) +(let ((.def_234 (___z5z___ .def_222))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_226 (= .def_225 1))) +(let ((.def_235 (or .def_226 .def_234))) +(let ((.def_229 (not .def_226))) +(let ((.def_236 (and .def_229 .def_235))) +(let ((.def_191 (___z6z___ .def_190))) +(let ((.def_237 (= .def_191 .def_236))) +.def_237 +)))))))))))) +(push 1) +(assert (let ((.def_334 (= _base (- 3)))) +(let ((.def_337 (not .def_334))) +(let ((.def_117 (___z3z___ 0))) +(let ((.def_346 (or .def_117 .def_337))) +(let ((.def_347 (not .def_346))) +.def_347 +)))))) +(assert true +) +(check-sat) +(pop 1) +(assert (let ((.def_349 (___z3z___ (- 4)))) +.def_349 +)) +(push 1) +(assert (let ((.def_240 (+ _n (- 2)))) +(let ((.def_278 (___z4z___ .def_240))) +(let ((.def_287 (not .def_278))) +(let ((.def_277 (___z5z___ .def_240))) +(let ((.def_283 (not .def_277))) +(let ((.def_290 (or .def_283 .def_287))) +(let ((.def_280 (___z6z___ .def_240))) +(let ((.def_291 (or .def_280 .def_290))) +(let ((.def_288 (and .def_277 .def_287))) +(let ((.def_285 (not .def_280))) +(let ((.def_289 (and .def_285 .def_288))) +(let ((.def_292 (or .def_289 .def_291))) +(let ((.def_284 (and .def_278 .def_283))) +(let ((.def_286 (and .def_284 .def_285))) +(let ((.def_293 (or .def_286 .def_292))) +(let ((.def_279 (and .def_277 .def_278))) +(let ((.def_281 (and .def_279 .def_280))) +(let ((.def_294 (or .def_281 .def_293))) +(let ((.def_282 (not .def_281))) +(let ((.def_295 (and .def_282 .def_294))) +(let ((.def_241 (___z3z___ .def_240))) +(let ((.def_296 (= .def_241 .def_295))) +.def_296 +))))))))))))))))))))))) +(assert (let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_299 (= .def_225 2))) +(let ((.def_240 (+ _n (- 2)))) +(let ((.def_297 (+ (- 1) .def_240))) +(let ((.def_298 (___z6z___ .def_297))) +(let ((.def_300 (or .def_298 .def_299))) +(let ((.def_278 (___z4z___ .def_240))) +(let ((.def_301 (= .def_278 .def_300))) +.def_301 +)))))))))) +(assert (let ((.def_240 (+ _n (- 2)))) +(let ((.def_297 (+ (- 1) .def_240))) +(let ((.def_303 (___z4z___ .def_297))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_299 (= .def_225 2))) +(let ((.def_304 (or .def_299 .def_303))) +(let ((.def_302 (not .def_299))) +(let ((.def_305 (and .def_302 .def_304))) +(let ((.def_277 (___z5z___ .def_240))) +(let ((.def_306 (= .def_277 .def_305))) +.def_306 +)))))))))))) +(assert (let ((.def_240 (+ _n (- 2)))) +(let ((.def_297 (+ (- 1) .def_240))) +(let ((.def_307 (___z5z___ .def_297))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_299 (= .def_225 2))) +(let ((.def_308 (or .def_299 .def_307))) +(let ((.def_302 (not .def_299))) +(let ((.def_309 (and .def_302 .def_308))) +(let ((.def_280 (___z6z___ .def_240))) +(let ((.def_310 (= .def_280 .def_309))) +.def_310 +)))))))))))) +(assert (let ((.def_313 (+ _n (- 3)))) +(let ((.def_351 (___z4z___ .def_313))) +(let ((.def_360 (not .def_351))) +(let ((.def_350 (___z5z___ .def_313))) +(let ((.def_356 (not .def_350))) +(let ((.def_363 (or .def_356 .def_360))) +(let ((.def_353 (___z6z___ .def_313))) +(let ((.def_364 (or .def_353 .def_363))) +(let ((.def_361 (and .def_350 .def_360))) +(let ((.def_358 (not .def_353))) +(let ((.def_362 (and .def_358 .def_361))) +(let ((.def_365 (or .def_362 .def_364))) +(let ((.def_357 (and .def_351 .def_356))) +(let ((.def_359 (and .def_357 .def_358))) +(let ((.def_366 (or .def_359 .def_365))) +(let ((.def_352 (and .def_350 .def_351))) +(let ((.def_354 (and .def_352 .def_353))) +(let ((.def_367 (or .def_354 .def_366))) +(let ((.def_355 (not .def_354))) +(let ((.def_368 (and .def_355 .def_367))) +(let ((.def_314 (___z3z___ .def_313))) +(let ((.def_369 (= .def_314 .def_368))) +.def_369 +))))))))))))))))))))))) +(assert (let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_372 (= .def_225 3))) +(let ((.def_313 (+ _n (- 3)))) +(let ((.def_370 (+ (- 1) .def_313))) +(let ((.def_371 (___z6z___ .def_370))) +(let ((.def_373 (or .def_371 .def_372))) +(let ((.def_351 (___z4z___ .def_313))) +(let ((.def_374 (= .def_351 .def_373))) +.def_374 +)))))))))) +(assert (let ((.def_313 (+ _n (- 3)))) +(let ((.def_370 (+ (- 1) .def_313))) +(let ((.def_376 (___z4z___ .def_370))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_372 (= .def_225 3))) +(let ((.def_377 (or .def_372 .def_376))) +(let ((.def_375 (not .def_372))) +(let ((.def_378 (and .def_375 .def_377))) +(let ((.def_350 (___z5z___ .def_313))) +(let ((.def_379 (= .def_350 .def_378))) +.def_379 +)))))))))))) +(assert (let ((.def_313 (+ _n (- 3)))) +(let ((.def_370 (+ (- 1) .def_313))) +(let ((.def_380 (___z5z___ .def_370))) +(let ((.def_224 (* (- 1) _base))) +(let ((.def_225 (+ _n .def_224))) +(let ((.def_372 (= .def_225 3))) +(let ((.def_381 (or .def_372 .def_380))) +(let ((.def_375 (not .def_372))) +(let ((.def_382 (and .def_375 .def_381))) +(let ((.def_353 (___z6z___ .def_313))) +(let ((.def_383 (= .def_353 .def_382))) +.def_383 +)))))))))))) +(assert (let ((.def_334 (= _base (- 3)))) +(let ((.def_337 (not .def_334))) +(let ((.def_188 (___z3z___ _n))) +(let ((.def_384 (or .def_188 .def_337))) +(let ((.def_385 (not .def_384))) +.def_385 +)))))) +(assert true +) +(check-sat) diff --git a/test/regress/regress1/uflia/stalmark_e7_27_e7_31.ec.smt2.expect b/test/regress/regress1/uflia/stalmark_e7_27_e7_31.ec.smt2.expect new file mode 100644 index 000000000..70b8fa26d --- /dev/null +++ b/test/regress/regress1/uflia/stalmark_e7_27_e7_31.ec.smt2.expect @@ -0,0 +1,7 @@ +% COMMAND-LINE: --incremental +% EXPECT: unsat +% EXPECT: sat +% EXPECT: unsat +% EXPECT: sat +% EXPECT: unsat +% EXPECT: unsat |