From 45029f8fe26c828952c460ab4862ab28d6181484 Mon Sep 17 00:00:00 2001
From: Armin Biere <biere@jku.at>
Date: Sat, 6 Jun 2020 16:29:27 +0200
Subject: [PATCH 1/2] SAT Competition 2020 Submission

---
 LICENSE                                       |   3 +-
 VERSION                                       |   2 +-
 configure                                     |  26 +-
 makefile.in                                   |   6 +-
 scripts/build-and-test-all-configurations.sh  |  17 +-
 scripts/generate-cubes.sh                     |  37 +
 scripts/make-build-header.sh                  |   2 +-
 ...ission.sh => prepare-sc2020-submission.sh} |   7 +-
 src/README.md                                 |   2 +-
 src/analyze.cpp                               |  91 +-
 src/block.cpp                                 |  30 +-
 src/cadical.cpp                               | 871 +++++++++++++-----
 src/cadical.hpp                               | 195 +++-
 src/ccadical.cpp                              |  76 +-
 src/ccadical.h                                |   3 +
 src/checker.cpp                               |  31 +-
 src/checker.hpp                               |  23 +-
 src/clause.cpp                                |  16 +-
 src/clause.hpp                                |  24 +-
 src/collect.cpp                               | 104 ++-
 src/compact.cpp                               |  44 +-
 src/condition.cpp                             |  31 +-
 src/config.cpp                                |  58 +-
 src/config.hpp                                |  15 +-
 src/contract.cpp                              |  27 +
 src/contract.hpp                              |  58 +-
 src/cover.cpp                                 |  19 +-
 src/decide.cpp                                |   7 +-
 src/decompose.cpp                             |  17 +-
 src/deduplicate.cpp                           |   6 +-
 src/elim.cpp                                  | 176 ++--
 src/extend.cpp                                |   2 +-
 src/external.cpp                              | 159 +++-
 src/external.hpp                              | 168 ++--
 src/flags.hpp                                 |  19 +-
 src/gates.cpp                                 |   3 +-
 src/instantiate.cpp                           |   4 +-
 src/internal.cpp                              | 284 +++---
 src/internal.hpp                              | 270 ++++--
 src/ipasir.cpp                                |   7 +
 src/ipasir.h                                  |   4 +
 src/limit.cpp                                 |  50 +-
 src/limit.hpp                                 |  13 +-
 src/lookahead.cpp                             | 430 +++++++++
 src/lucky.cpp                                 | 121 ++-
 src/message.cpp                               |   6 +-
 src/message.hpp                               |  17 +-
 src/mobical.cpp                               | 469 ++++++----
 src/occs.cpp                                  |   2 +-
 src/options.cpp                               | 134 +--
 src/options.hpp                               | 387 ++++----
 src/parse.cpp                                 | 223 +++--
 src/parse.hpp                                 |  36 +-
 src/phases.cpp                                |  25 +-
 src/phases.hpp                                |   7 +-
 src/probe.cpp                                 |  72 +-
 src/profile.hpp                               |   5 +-
 src/propagate.cpp                             |  11 +-
 src/random.hpp                                |  24 +-
 src/range.hpp                                 |  93 ++
 src/reduce.cpp                                |  31 +-
 src/rephase.cpp                               |  10 +-
 src/report.cpp                                |   4 +-
 src/resources.cpp                             | 139 ++-
 src/resources.hpp                             |   7 +-
 src/restore.cpp                               |   4 +-
 src/score.cpp                                 |   8 +-
 src/solution.cpp                              |   8 +-
 src/solver.cpp                                | 200 +++-
 src/stats.cpp                                 |  21 +-
 src/stats.hpp                                 |   1 +
 src/subsume.cpp                               |  61 +-
 src/terminal.hpp                              |   1 +
 src/ternary.cpp                               |  12 +-
 src/tracer.hpp                                |   7 +-
 src/transred.cpp                              |  14 +-
 src/util.cpp                                  |  77 +-
 src/util.hpp                                  |  32 +-
 src/var.cpp                                   |   8 +-
 src/var.hpp                                   |   8 +-
 src/version.cpp                               |  14 +-
 src/vivify.cpp                                |  24 +-
 src/walk.cpp                                  |   6 +-
 src/watch.cpp                                 |  46 +-
 test/api/cipasir.c                            |  95 ++
 test/api/learn.cpp                            |  58 ++
 test/api/run.sh                               |   5 +-
 test/icnf/empty.icnf                          |   1 +
 test/icnf/false.icnf                          |   2 +
 test/icnf/run.sh                              |  87 ++
 test/icnf/two1.icnf                           |   7 +
 test/icnf/two2.icnf                           |   7 +
 test/icnf/unit1.icnf                          |   3 +
 test/icnf/unit2.icnf                          |   3 +
 test/makefile                                 |   6 +-
 test/trace/reg0053.trace                      |   3 +
 test/trace/reg0054.trace                      |   5 +
 test/trace/reg0055.trace                      |  14 +
 test/usage/relaxed-header.cnf                 |   5 +
 test/usage/run.sh                             |   6 +
 100 files changed, 4464 insertions(+), 1655 deletions(-)
 create mode 100755 scripts/generate-cubes.sh
 rename scripts/{prepare-sr2019-submission.sh => prepare-sc2020-submission.sh} (86%)
 create mode 100644 src/contract.cpp
 create mode 100644 src/lookahead.cpp
 create mode 100644 src/range.hpp
 create mode 100644 test/api/cipasir.c
 create mode 100644 test/api/learn.cpp
 create mode 100644 test/icnf/empty.icnf
 create mode 100644 test/icnf/false.icnf
 create mode 100755 test/icnf/run.sh
 create mode 100644 test/icnf/two1.icnf
 create mode 100644 test/icnf/two2.icnf
 create mode 100644 test/icnf/unit1.icnf
 create mode 100644 test/icnf/unit2.icnf
 create mode 100644 test/trace/reg0053.trace
 create mode 100644 test/trace/reg0054.trace
 create mode 100644 test/trace/reg0055.trace
 create mode 100644 test/usage/relaxed-header.cnf

diff --git a/LICENSE b/LICENSE
index 23d808a1..52e39d02 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2016-2019 Armin Biere, Johannes Kepler University Linz, Austria
+Copyright (c) 2016-2020 Armin Biere, Johannes Kepler University Linz, Austria
+Copyright (c) 2020 Mathias Fleury, Johannes Kepler University Linz, Austria
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/VERSION b/VERSION
index 6085e946..6582e891 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.2.1
+sc2020
diff --git a/configure b/configure
index f1ffa1f3..c45a7b87 100755
--- a/configure
+++ b/configure
@@ -18,8 +18,11 @@ all=no
 debug=no
 logging=no
 check=no
+competition=no
 coverage=no
 profile=no
+contracts=yes
+tracing=yes
 unlocked=yes
 pedantic=no
 options=""
@@ -79,7 +82,7 @@ where '<option>' is one of the following
 -g|--debug         compile with debugging information
 -c|--check         compile with assertion checking (default for '-g')
 -l|--log[ging]     include logging code (but disabled by default)
--a|--all           short cut for all above, e.g., '-g -l -s' (thus also '-c')
+-a|--all           short cut for all above, e.g., '-g -l' (thus also '-c')
 -q|--quiet         exclude message and profiling code (logging too)
 -p|--pedantic      add '--pedantic' and '-Werror' compilation flag
 -s|--symbols       add '-ggdb3' (even for optimized compilation)
@@ -87,6 +90,12 @@ where '<option>' is one of the following
 --coverage         compile with '-ftest-coverage -fprofile-arcs' for 'gcov'
 --profile          compile with '-pg' to profile with 'gprof'
 
+--no-contracts     compile without API contract checking code
+--no-tracing       compile without API call tracing code
+
+--competition      configure for the competition
+                   ('--quiet', '--no-contracts', '--no-tracing')
+
 -f...              pass '-f<option>[=<val>]' options to the makefile
 -m32               pass '-m32' to the compiler (compile for 32 bit)
 -ggdb3             pass '-ggdb3' to makefile (like '-s')
@@ -135,9 +144,14 @@ do
     -p|--pedantic) pedantic=yes;;
     -q|--quiet) quiet=yes;;
 
+    --no-contracts | --no-contract) contracts=no;;
+    --no-tracing | --no-trace) tracing=no;;
+
     --coverage) coverage=yes;;
     --profile) profile=yes;;
 
+    --competition) competition=yes;;
+
     --no-unlocked) unlocked=no;;
 
     -j*) MAKEFLAGS="$1";;
@@ -255,12 +269,21 @@ then
   esac
 fi
 
+if [ $competition = yes ]
+then
+  quiet=yes
+  contracts=no
+  tracing=no
+fi
+
 [ $check = no ] && CXXFLAGS="$CXXFLAGS -DNDEBUG"
 [ $logging = yes ] && CXXFLAGS="$CXXFLAGS -DLOGGING"
 [ $quiet = yes ] && CXXFLAGS="$CXXFLAGS -DQUIET"
 [ $profile = yes ] && CXXFLAGS="$CXXFLAGS -pg"
 [ $coverage = yes ] && CXXFLAGS="$CXXFLAGS -ftest-coverage -fprofile-arcs"
 [ $pedantic = yes ] && CXXFLAGS="$CXXFLAGS --pedantic -Werror"
+[ $contracts = no ] && CXXFLAGS="$CXXFLAGS -DNCONTRACTS"
+[ $tracing = no ] && CXXFLAGS="$CXXFLAGS -DNTRACING"
 
 CXXFLAGS="$CXXFLAGS$options"
 
@@ -416,7 +439,6 @@ clean:
 	  if [ -f "\$(CADICALBUILD)"/makefile ]; \\
 	  then \\
 	     touch "\$(CADICALBUILD)"/build.hpp; \\
-	     touch "\$(CADICALBUILD)"/dependencies; \\
 	     \$(MAKE) -C "\$(CADICALBUILD)" clean; \\
 	  fi; \\
 	  rm -rf "\$(CADICALBUILD)"; \\
diff --git a/makefile.in b/makefile.in
index aa0f505b..5daea913 100644
--- a/makefile.in
+++ b/makefile.in
@@ -19,9 +19,9 @@ MAKEFLAGS=@MAKEFLAGS@
 ############################################################################
 
 APP=cadical.cpp mobical.cpp
-ALL=$(sort $(wildcard ../src/*.[ch]pp))
-SRC=$(filter %.cpp,$(subst ../src/,,$(ALL)))
-LIB=$(filter-out $(APP),$(SRC))
+SRC=$(sort $(wildcard ../src/*.cpp))
+SUB=$(subst ../src/,,$(SRC))
+LIB=$(filter-out $(APP),$(SUB))
 OBJ=$(LIB:.cpp=.o)
 DIR=../$(shell pwd|sed -e 's,.*/,,')
 COMPILE=$(CXX) $(CXXFLAGS) -I$(DIR)
diff --git a/scripts/build-and-test-all-configurations.sh b/scripts/build-and-test-all-configurations.sh
index c21b451c..6dc0e594 100755
--- a/scripts/build-and-test-all-configurations.sh
+++ b/scripts/build-and-test-all-configurations.sh
@@ -60,8 +60,15 @@ run () {
 
 ############################################################################
 
-run		# default configuration
-run -p		# check pedantic first
+# start with these two for fast fail
+
+run -j		# default configuration with fast parallel compilation
+run -j -p	# check pedantic in parallel
+
+run		# default configuration (depends on 'MAKEFLAGS'!)
+run -p		# then check default pedantic first
+
+run -j1		# forced slow sequential compilation (checks '-j1' option)
 
 run -q		# library users might want to disable messages
 run -q -p	# also check '--quiet' pedantically
@@ -100,4 +107,10 @@ run -m32 -a -p
 run --no-unlocked -q
 run --no-unlocked -a -p
 
+run --no-contracts -q
+run --no-contracts -a -p
+
+run --no-tracing -q
+run --no-tracing -a -p
+
 echo "successfully compiled and tested ${GOOD}${ok}${NORMAL} configurations"
diff --git a/scripts/generate-cubes.sh b/scripts/generate-cubes.sh
new file mode 100755
index 00000000..7b936ac6
--- /dev/null
+++ b/scripts/generate-cubes.sh
@@ -0,0 +1,37 @@
+#!/bin/sh
+usage () {
+cat <<EOF 2>&1
+usage: generate-cubes.sh [-h] <input> [ <output> [ <march_cu option> ... ] ]
+EOF
+exit 0
+}
+[ "$1" = -h ] && usage
+die () {
+  echo "generate-cubes.sh: error: $*" 1>&2
+  exit 1
+}
+[ $# -lt 1 ] && die "expected DIMACS file argument"
+output=""
+options=""
+[ -f "$1" ] || die "first argument is not a DIMACS file"
+input="$1"
+shift
+while [ $# -gt 0 ]
+do
+  case "$1" in
+    -*) options="$options $1";;
+    *) exec 1>"$1";;
+  esac
+  shift
+done
+prefix=/tmp/generate-cubes-$$
+cleanup () {
+  rm -f $prefix*
+}
+trap "cleanup" 2 11
+cubes=$prefix.cubes
+march_cu $input -o $cubes $options 1>&2 || exit 1
+sed -e 's,^p cnf.*,p inccnf,' $input
+cat $cubes
+cleanup
+exit 0
diff --git a/scripts/make-build-header.sh b/scripts/make-build-header.sh
index acfa7395..98a8f458 100755
--- a/scripts/make-build-header.sh
+++ b/scripts/make-build-header.sh
@@ -76,7 +76,7 @@ else
 fi
 
 #--------------------------------------------------------------------------#
-# Use time of executing this script as build time.
+# Use time of executing this script at build time.
 #
 LC_TIME="en_US" # Avoid umlaut in 'DATE'.
 export LC_TIME
diff --git a/scripts/prepare-sr2019-submission.sh b/scripts/prepare-sc2020-submission.sh
similarity index 86%
rename from scripts/prepare-sr2019-submission.sh
rename to scripts/prepare-sc2020-submission.sh
index 819e4a81..d9fb5f6d 100755
--- a/scripts/prepare-sr2019-submission.sh
+++ b/scripts/prepare-sc2020-submission.sh
@@ -1,7 +1,7 @@
 #!/bin/sh
 cd `dirname $0`/..
 root=`pwd`
-tmp=/tmp/prepare-cadical-sr2018-submission.log
+tmp=/tmp/prepare-cadical-sc2020-submission.log
 VERSION=`cat VERSION`
 rm -f $tmp
 ##########################################################################
@@ -25,7 +25,7 @@ cat <<EOF >$dir/build/build.sh
 tar xf ../archives/cadical*
 mv cadical* cadical
 cd cadical
-./configure
+./configure --competition
 make test
 install -s build/cadical ../../bin/
 EOF
@@ -41,6 +41,9 @@ cat <<EOF >$dir/bin/starexec_run_default
 exec ./cadical --$option \$1 \$2/proof.out
 EOF
 chmod 755 $dir/bin/starexec_run_default
+description=$dir/starexec_description.txt
+grep '^CaDiCaL' README.md|head -1 >$description
+cat $description
 archive=/tmp/$base.zip
 rm -f $archive
 cd $dir
diff --git a/src/README.md b/src/README.md
index 8019bf5c..f17395f7 100644
--- a/src/README.md
+++ b/src/README.md
@@ -2,7 +2,7 @@ This is the source code of the library `libcadical.a` with header
 `cadical.hpp`, the stand-alone solver `cadical` (in `cadical.cpp`) and the
 model based tester `mobical` (in `mobical.app`).
 
-The links to the `configure` script and the `makefile` in the root directory
+The `configure` script and link to the `makefile` in the root directory
 can be used from within the `src` sub-directory too and then will just work
 as if used from the root directory.  For instance
 
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 42060ecc..ae156802 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -63,10 +63,10 @@ static inline bool evsids_limit_hit (double score) {
 
 // Classical exponential VSIDS as pioneered by MiniSAT.
 
-void Internal::rescore () {
+void Internal::rescale_variable_scores () {
   stats.rescored++;
-  double divider = scinc;
-  for (int idx = 1; idx <= max_var; idx++) {
+  double divider = score_inc;
+  for (auto idx : vars) {
     const double tmp = stab[idx];
     if (tmp > divider) divider = tmp;
   }
@@ -74,26 +74,26 @@ void Internal::rescore () {
     "rescoring %d variable scores by 1/%g", max_var, divider);
   assert (divider > 0);
   double factor = 1.0 / divider;
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     stab[idx] *= factor;
-  scinc *= factor;
+  score_inc *= factor;
   PHASE ("rescore", stats.rescored,
     "new score increment %g after %" PRId64 " conflicts",
-    scinc, stats.conflicts);
+    score_inc, stats.conflicts);
 }
 
-void Internal::bump_score (int lit) {
+void Internal::bump_variable_score (int lit) {
   assert (opts.bump);
   int idx = vidx (lit);
   double old_score = score (idx);
   assert (!evsids_limit_hit (old_score));
-  double new_score = old_score + scinc;
+  double new_score = old_score + score_inc;
   if (evsids_limit_hit (new_score)) {
     LOG ("bumping %g score of %d hits EVSIDS score limit", old_score, idx);
-    rescore ();
+    rescale_variable_scores ();
     old_score = score (idx);
     assert (!evsids_limit_hit (old_score));
-    new_score = old_score + scinc;
+    new_score = old_score + score_inc;
   }
   assert (!evsids_limit_hit (new_score));
   LOG ("new %g score of %d", new_score, idx);
@@ -104,26 +104,27 @@ void Internal::bump_score (int lit) {
 // Important variables recently used in conflict analysis are 'bumped',
 
 void Internal::bump_variable (int lit) {
-  if (use_scores ()) bump_score (lit);
+  if (use_scores ()) bump_variable_score (lit);
   else bump_queue (lit);
 }
 
-// After every conflict we increase the score increment by a factor.
+// After every conflict the variable score increment is increased by a
+// factor (if we are currently using scores).
 
-void Internal::bump_scinc () {
+void Internal::bump_variable_score_inc () {
   assert (use_scores ());
-  assert (!evsids_limit_hit (scinc));
+  assert (!evsids_limit_hit (score_inc));
   double f = 1e3/opts.scorefactor;
-  double new_scinc = scinc * f;
-  if (evsids_limit_hit (new_scinc)) {
-    LOG ("bumping %g increment by %g hits EVSIDS score limit", scinc, f);
-    rescore ();
-    new_scinc = scinc * f;
+  double new_score_inc = score_inc * f;
+  if (evsids_limit_hit (new_score_inc)) {
+    LOG ("bumping %g increment by %g hits EVSIDS score limit", score_inc, f);
+    rescale_variable_scores ();
+    new_score_inc = score_inc * f;
   }
-  assert (!evsids_limit_hit (new_scinc));
+  assert (!evsids_limit_hit (new_score_inc));
   LOG ("bumped score increment from %g to %g with factor %g",
-    scinc, new_scinc, f);
-  scinc = new_scinc;
+    score_inc, new_score_inc, f);
+  score_inc = new_score_inc;
 }
 
 /*------------------------------------------------------------------------*/
@@ -159,9 +160,10 @@ void Internal::bump_variables () {
   if (!use_scores ()) {
 
     // Variables are bumped in the order they are in the current decision
-    // queue.  This maintains relative order between bumped variables in the
-    // queue and seems to work best.  We also experimented with focusing on
-    // variables of the last decision level, but results were mixed.
+    // queue.  This maintains relative order between bumped variables in
+    // the queue and seems to work best.  We also experimented with
+    // focusing on variables of the last decision level, but results were
+    // mixed.
 
     MSORT (opts.radixsortlim,
       analyzed.begin (), analyzed.end (),
@@ -171,7 +173,7 @@ void Internal::bump_variables () {
   for (const auto & lit : analyzed)
     bump_variable (lit);
 
-  if (use_scores ()) bump_scinc ();
+  if (use_scores ()) bump_variable_score_inc ();
 
   STOP (bump);
 }
@@ -194,7 +196,7 @@ int Internal::recompute_glue (Clause * c) {
 }
 
 // Clauses resolved since the last reduction are marked as 'used', their
-// glue is recomputed and they promoted if the glue shrinks.  Note that
+// glue is recomputed and they are promoted if the glue shrinks.  Note that
 // promotion from 'tier3' to 'tier2' will set 'used' to '2'.
 
 inline void Internal::bump_clause (Clause * c) {
@@ -253,6 +255,15 @@ Internal::analyze_reason (int lit, Clause * reason, int & open) {
 /*------------------------------------------------------------------------*/
 
 // This is an idea which was implicit in MapleCOMSPS 2016 for 'limit = 1'.
+// See also the paragraph on 'bumping reason side literals' in their SAT'16
+// paper [LiangGaneshPoupartCzarnecki-SAT'16].  Reason side bumping was
+// performed exactly when 'LRB' based decision heuristics was used, which in
+// the original version was enabled after 10000 conflicts until a time limit
+// of 2500 seconds was reached (half of the competition time limit).  The
+// Maple / Glucose / MiniSAT evolution winning the SAT race in 2019 made
+// the schedule of reason side bumping deterministic, i.e., avoiding a time
+// limit, by switching between 'LRB' and 'VSIDS' in an interval of initially
+// 30 million propagations, which then is increased geometrically by 10%.
 
 inline bool Internal::bump_also_reason_literal (int lit) {
   assert (lit);
@@ -267,6 +278,8 @@ inline bool Internal::bump_also_reason_literal (int lit) {
   return true;
 }
 
+// We experimented with deeper reason bumping without much success though.
+
 inline void Internal::bump_also_reason_literals (int lit, int limit) {
   assert (lit);
   assert (limit > 0);
@@ -286,6 +299,7 @@ inline void Internal::bump_also_reason_literals (int lit, int limit) {
 inline void Internal::bump_also_all_reason_literals () {
   assert (opts.bumpreason);
   assert (opts.bumpreasondepth > 0);
+  LOG ("bumping reasons up to depth %d", opts.bumpreasondepth);
   for (const auto & lit : clause)
     bump_also_reason_literals (-lit, opts.bumpreasondepth);
 }
@@ -378,8 +392,7 @@ Clause * Internal::new_driving_clause (const int glue, int & jump) {
 
     jump = var (clause[1]).level;
     res = new_learned_redundant_clause (glue);
-    if (glue <= opts.reducetier2glue) res->used = 2;
-    else res->used = 1;
+    res->used = 1 + (glue <= opts.reducetier2glue);
   }
 
   LOG ("jump level %d", jump);
@@ -440,18 +453,26 @@ inline int Internal::find_conflict_level (int & forced) {
       highest_position = j;
       highest_level = tmp;
       if (highest_level == res) break;
+#if 0
       if (i && highest_level == res - 1) break;
+#endif
     }
 
     // No unwatched higher assignment level literal.
     //
-    if (highest_position < 2) continue;
+    if (highest_position == i) continue;
+
+    if (highest_position > 1)
+      {
+	LOG (conflict, "unwatch %d in", lit);
+	remove_watch (watches (lit), conflict);
+      }
 
-    LOG (conflict, "unwatch %d in", lit);
-    remove_watch (watches (lit), conflict);
     lits[highest_position] = lit;
     lits[i] = highest_literal;
-    watch_literal (highest_literal, lits[!i], conflict);
+
+    if (highest_position > 1)
+      watch_literal (highest_literal, lits[!i], conflict);
   }
 
   // Only if the number of highest level literals in the conflict is one
@@ -650,6 +671,7 @@ void Internal::analyze () {
   //
   if (!level) {
     learn_empty_clause ();
+    if (external->learner) external->export_learned_empty_clause ();
     STOP (analyze);
     return;
   }
@@ -715,7 +737,8 @@ void Internal::analyze () {
   if (size > 1) {
     if (opts.minimize) minimize_clause ();
     size = (int) clause.size ();
-  }
+    if (external->learner) external->export_learned_large_clause (clause);
+  } else if (external->learner) external->export_learned_unit_clause (-uip);
 
   // Update actual size statistics.
   //
diff --git a/src/block.cpp b/src/block.cpp
index 374ef936..c4c07572 100644
--- a/src/block.cpp
+++ b/src/block.cpp
@@ -178,14 +178,11 @@ void Internal::block_schedule (Blocker & blocker)
   // is expensive to remove references to garbage clauses from 'occs' during
   // blocked clause elimination, but decrementing 'noccs' is cheap.
 
-  for (int idx = 1; idx <= max_var; idx++) {
-    if (!active (idx)) continue;
-    assert (!val (idx));
-    for (int sign = -1; sign <= 1; sign += 2) {
-      const int lit = sign * idx;
-      Occs & os = occs (lit);
-      noccs (lit) = os.size ();
-    }
+  for (auto lit : lits) {
+    if (!active (lit)) continue;
+    assert (!val (lit));
+    Occs & os = occs (lit);
+    noccs (lit) = os.size ();
   }
 
   // Now we fill the schedule (priority queue) of candidate literals to be
@@ -197,7 +194,7 @@ void Internal::block_schedule (Blocker & blocker)
 
   int skipped = 0;
 
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     if (!active (idx)) continue;
     if (frozen (idx)) { skipped += 2; continue; }
     assert (!val (idx));
@@ -649,8 +646,9 @@ void Internal::block_literal (Blocker & blocker, int lit)
   if (!noccs (-lit)) block_pure_literal (blocker, lit);
   else if (!noccs (lit)) {
     // Rare situation, where the clause length limit was hit for 'lit' and
-    // '-lit' is skipped and then it becomes pure.  Can be ignored.
-    assert (frozen (lit) || marked_skip (-lit));
+    // '-lit' is skipped and then it becomes pure.  Can be ignored.  We also
+    // so it once happing for a 'elimboundmin=-1' and zero positive and one
+    // negative occurrence.
   } else if (noccs (-lit) == 1)
     block_literal_with_one_negative_occ (blocker, lit);
   else
@@ -669,9 +667,9 @@ void Internal::block_literal (Blocker & blocker, int lit)
 bool Internal::block () {
 
   if (!opts.block) return false;
-  if (unsat || terminating () || !stats.current.irredundant) return false;
-
-  assert (opts.simplify);
+  if (unsat) return false;
+  if (!stats.current.irredundant) return false;
+  if (terminated_asynchronously ()) return false;
 
   if (propagated < trail.size ()) {
     LOG ("need to propagate %zd units first", trail.size () - propagated);
@@ -682,7 +680,7 @@ bool Internal::block () {
       learn_empty_clause ();
       assert (unsat);
     }
-    disconnect_watches ();
+    clear_watches ();
     reset_watches ();
     if (unsat) return false;
   }
@@ -710,7 +708,7 @@ bool Internal::block () {
   int64_t purelits = stats.blockpurelits;
   int64_t pured = stats.blockpured;
 
-  while (!terminating () &&
+  while (!terminated_asynchronously () &&
          !blocker.schedule.empty ()) {
     int lit = u2i (blocker.schedule.front ());
     blocker.schedule.pop_front ();
diff --git a/src/cadical.cpp b/src/cadical.cpp
index 5fb406f3..e70015f5 100644
--- a/src/cadical.cpp
+++ b/src/cadical.cpp
@@ -3,61 +3,159 @@
 // Do include 'internal.hpp' but try to minimize internal dependencies.
 
 #include "internal.hpp"
-#include "signal.hpp"
+#include "signal.hpp"           // Separate, only need for apps.
 
 /*------------------------------------------------------------------------*/
 
 namespace CaDiCaL {
 
-class Solver;
-class File;
-
 // A wrapper app which makes up the CaDiCaL stand alone solver.  It in
 // essence only consists of the 'App::main' function.  So this class
 // contains code, which is not required if only the library interface in
-// 'Solver' is used.  It further uses static data structures in order to
-// have a signal handler catch signals.
+// the class 'Solver' is used (defined in 'cadical.hpp').  It further uses
+// static data structures in order to have a signal handler catch signals.
 //
 // It is thus neither thread-safe nor reentrant.  If you want to use
 // multiple instances of the solver use the 'Solver' interface directly
 // which is thread-safe and reentrant among different solver instances.
 
+/*------------------------------------------------------------------------*/
+
+// Jobs for running multiple solvers (sequentially and later in parallel).
+
+struct Job
+{
+  int left;             // Number of discrepancies.
+  int depth;            // Splitting depth.
+  int64_t id;           // Unique identifier.
+  string path;          // Path from root node ('0'=left '1'=right).
+
+  Job * parent;         // Parent job.
+  Solver * solver;      // This solver (might be zero).
+
+  Job (Job * p, Solver * s) : parent  (p), solver (s) { }
+  ~Job () { if (solver) delete solver; }
+
+  // Compare jobs and prefer low discrepancy jobs (are smaller).
+  //
+  bool less (const Job & other) const {
+    if (solver && !other.solver) return true;
+    if (!solver && other.solver) return false;
+    if (solver) {
+      if (left > other.left) return true;
+      if (left < other.left) return false;
+    }
+    return id < other.id;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
 class App : public Handler, public Terminator {
 
-  // Global solver.
+  Solver * root;                // Global root solver.
+  Solver * winner;              // Solver which found solution.
 
-  Solver * solver;
-  int time_limit;
-  int max_var;
-  int strict;   // 0=force, 1=relaxed, 2=strict
-  bool timesup;
+  vector<Job *> jobs;           // Our job working queue.
 
-  // Printing.
+  bool multiple;                // Set implicitly by '-p', '-D' etc.
+
+  // Command line options.
+  //
+  // bool parallel;             // '-p'
+  int max_depth;                // '-D<level>'
+  // int max_solvers;           // '-S<solvers>'
+  // int max_threads;           // '-T<threads>'
+  int time_limit;               // '-t <sec>'
 
+  // Strictness of (DIMACS) parsing:
+  //
+  //  0 = force parsing and completely ignore header
+  //  1 = relaxed header handling (default)
+  //  2 = strict header handling
+  //
+  // To use '0' use '-f' of '--force'.
+  // To use '2' use '--strict'.
+  //
+  int force_strict_parsing;
+
+  bool force_writing;
+  static bool most_likely_existing_cnf_file (const char * path);
+
+  // Shared global statistics over all solvers.
+  //
+  struct {
+    int64_t solvers;
+    int64_t decisions;
+    int64_t conflicts;
+  } stats;
+
+  // Internal variables.
+  //
+  int max_var;                  // Set after parsing.
+  volatile bool timesup;        // Asynchronous termination.
+
+  // Printing.
+  //
   void print_usage (bool all = false);
   void print_witness (FILE *);
 
-  // Option handling.
-
-  bool verbose () { return get ("verbose") && !get ("quiet"); }
+#ifndef QUIET
+  void signal_message (const char * msg, int sig);
+#endif
 
-  int  get (const char*);
+  // Option handling.
+  //
   bool set (const char*);
   bool set (const char*, int);
+  int  get (const char*);
+  bool verbose () { return get ("verbose") && !get ("quiet"); }
 
-public:
+  /*----------------------------------------------------------------------*/
 
-  App ();
-  ~App ();
+  void initialize_root () {
+    root = new Solver ();
+    Job * res = new Job (0, root);
+    jobs.push_back (res);
+    res->id = stats.solvers++;
+    res->depth = 0;
+    res->left = 0;
+  }
+
+  bool split () {
+    if (!max_depth) return false;
+    Job * best = 0;
+    for (auto & job : jobs)
+      if (job->solver && (!best || job->less (*best)))
+        best = job;
+    if (!best) return false;
+    // TODO check memory limit ...
+    // TODO split ...
+    return false;
+  }
+
+  /*----------------------------------------------------------------------*/
 
+  // The actual initialization.
+  //
+  void init ();
+
+  // Terminator interface.
+  //
   bool terminate () { return timesup; }
 
-#ifndef QUIET
-  void signal_message (const char * msg, int sig);
-#endif
+  // Handler interface.
+  //
   void catch_signal (int sig);
   void catch_alarm ();
 
+public:
+
+  App ();
+  ~App ();
+
+  // Parse the arguments and run the solver.
+  //
   int main (int arg, char ** argv);
 };
 
@@ -65,50 +163,70 @@ class App : public Handler, public Terminator {
 
 void App::print_usage (bool all) {
   printf (
-"usage: cadical [ <option> ... ] [ <dimacs> [ <proof> ] ]\n"
-"\n"
-"where '<option>' is one of the following common options\n"
+"usage: cadical [ <option> ... ] [ <input> [ <proof> ] ]\n"
 "\n"
-"  -h             list of common options \n"
-"  --help         list of advanced options\n"
+"where '<option>' is one of the following common options:\n"
+"\n");
+
+  if (!all) {      // Print only a short list of common options.
+    printf (
+"  -h             print this short list of common options\n"
+"  --help         print complete list of all options\n"
 "  --version      print version\n"
 "\n"
-"  -n             do not print witness%s\n"
+#if 0
+"  -p             enable parallel solving\n"
+#endif
+"  -n             do not print witness\n"
 #ifndef QUIET
-"  -v             increase verbosity%s\n"
-"  -q             be quiet%s\n"
+"  -v             increase verbosity\n"
+"  -q             be quiet\n"
 #endif
 "\n"
 "  -t <sec>       set wall clock time limit\n"
-,
-  all ? " (same as '--no-witness')": ""
+    );
+  } else {         // Print complete list of all options.
+    printf (
+"  -h             print alternatively only a list of common options\n"
+"  --help         print this complete list of all options\n"
+"  --version      print version\n"
+"\n"
+#if 0
+"  -p             enable parallel solving\n"
+#endif
+"  -n             do not print witness (same as '--no-witness')\n"
 #ifndef QUIET
-  , all ? " (see also '--verbose')": ""
-  , all ? " (same as '--quiet')" : ""
+"  -v             increase verbosity (see also '--verbose' below)\n"
+"  -q             be quiet (same as '--quiet')\n"
 #endif
-  );
-
-  if (all) {    // Print complete list of options.
-
-    printf (
+"  -t <sec>       set wall clock time limit\n"
+"\n"
+"Or '<option>' is one of the less common options\n"
 "\n"
-"or one of the less common options\n"
+"  -L<rounds>     run local search initially (default '0' rounds)\n"
+"  -O<level>      increase limits by '2^<level>' or '10^<level>'\n"
+"  -P<rounds>     initial preprocessing (default '0' rounds)\n"
+#if 0
 "\n"
-"  -O<level>      increase limits by '{2,10}^<level>' (default '0')\n"
-"  -P<rounds>     enable preprocessing initially (default '0' rounds)\n"
-"  -L<rounds>     run local search initialially (default '0' rounds)\n"
+"  -D<level>      maximum depth of multiple solvers (default '1')\n"
+"  -S<solvers>    maximum number of solvers solvers (default '1')\n"
+"  -T<threads>    number of threads (default '%d' on this machine)\n"
+#endif
+"\n"
+"Note there is no separating space for the options above while the\n"
+"following options require a space after the option name:\n"
 "\n"
 "  -c <limit>     limit the number of conflicts (default unlimited)\n"
 "  -d <limit>     limit the number of decisions (default unlimited)\n"
 "\n"
-"  -o <dimacs>    write simplified CNF in DIMACS format to file\n"
+"  -o <output>    write simplified CNF in DIMACS format to file\n"
 "  -e <extend>    write reconstruction/extension stack to file\n"
 #ifdef LOGGING
 "  -l             enable logging messages (same as '--log')\n"
 #endif
 "\n"
-"  -f | --force   parse completely broken DIMACS header\n"
-"  --strict       enforce strict parsing\n"
+"  --force | -f   parsing broken DIMACS header and writing proofs\n"
+"  --strict       strict parsing (no white space in header)\n"
 "\n"
 "  -s <sol>       read solution in competition output format\n"
 "                 to check consistency of learned clauses\n"
@@ -120,11 +238,23 @@ void App::print_usage (bool all) {
 "\n"
 "  --build        print build configuration\n"
 "  --copyright    print copyright information\n"
+#if 0
+, number_of_cores ()
+#endif
+    );
+
+    printf (
 "\n"
-"or '<option>' is one of the following advanced internal options\n"
+"There are pre-defined configurations of advanced internal options:\n"
 "\n");
 
-    solver->usage ();
+    root->configurations ();
+
+    printf (
+"\n"
+"Or '<option>' is one of the following advanced internal options:\n"
+"\n");
+    root->usage ();
 
     fputs (
 "\n"
@@ -141,30 +271,33 @@ void App::print_usage (bool all) {
 "the DIMACS file have highest priority, followed by command line\n"
 "options and then values specified through environment variables.\n",
      stdout);
-
-    printf (
-"\n"
-"There are also the following pre-defined configurations of options\n"
-"\n");
-
-    solver->configurations ();
   }
 
+  //------------------------------------------------------------------------
   // Common to both complete and common option usage.
-  //
+
   fputs (
 "\n"
-"The input is read from '<dimacs>' assumed to be in DIMACS format.\n"
+"The input is read from '<input>' assumed to be in DIMACS format.\n"
+"Incremental 'p inccnf' files are supported too with cubes at the end.\n"
 "If '<proof>' is given then a DRAT proof is written to that file.\n",
    stdout);
 
+  //------------------------------------------------------------------------
+  // More explanations for complete option usage.
+
   if (all) {
     fputs (
 "\n"
-"If '<dimacs>' is missing then the solver reads from '<stdin>',\n"
-"also if '-' is used as input path name '<dimacs>'.  Similarly,\n"
-"if '-' is specified as '<proof>' path then a proof is generated\n"
-"and printed to '<stdout>'.\n"
+"If '<input>' is missing then the solver reads from '<stdin>',\n"
+"also if '-' is used as input path name '<input>'.  Similarly,\n"
+"\n"
+"For incremental files each cube is solved in turn. The solver\n"
+"stops at the first satisfied cube if there is one and uses that\n"
+"one for the witness to print.  Conflict and decision limits are\n"
+"applied to each individual cube solving call while '-P', '-L' and\n"
+"'-t' remain global.  Only if all cubes were unsatisfiable the solver\n"
+"prints the standard unsatisfiable solution line ('s UNSATISFIABLE').\n"
 "\n"
 "By default the proof is stored in the binary DRAT format unless\n"
 "the option '--no-binary' is specified or the proof is written\n"
@@ -174,7 +307,9 @@ void App::print_usage (bool all) {
 "and has a '.gz', '.bz2', '.xz' or '.7z' suffix.  The same applies\n"
 "to the output file.  In order to use compression and decompression\n"
 "the corresponding utilities 'gzip', 'bzip', 'xz', and '7z' (depending\n"
-"on the format) are required and need to be installed on the system.\n",
+"on the format) are required and need to be installed on the system.\n"
+"The solver checks file type signatures though and falls back to\n"
+"non-compressed file reading if the signature does not match.\n",
     stdout);
   }
 }
@@ -182,13 +317,14 @@ void App::print_usage (bool all) {
 /*------------------------------------------------------------------------*/
 
 // Pretty print competition format witness with 'v' lines.
-//
+
 void App::print_witness (FILE * file) {
+  assert (winner);
   int c = 0, i = 0, tmp;
   do {
     if (!c) fputc ('v', file), c = 1;
     if (i++ == max_var) tmp = 0;
-    else tmp = solver->val (i) < 0 ? -i : i;
+    else tmp = winner->val (i) < 0 ? -i : i;
     char str[20];
     sprintf (str, " %d", tmp);
     int l = strlen (str);
@@ -203,44 +339,94 @@ void App::print_witness (FILE * file) {
 
 // Wrapper around option setting.
 
-int App::get (const char * o) { return solver->get (o); }
-bool App::set (const char * o, int v) { return solver->set (o, v); }
-bool App::set (const char * arg) { return solver->set_long_option (arg); }
+int App::get (const char * o) { return root->get (o); }
+bool App::set (const char * o, int v) { return root->set (o, v); }
+bool App::set (const char * arg) { return root->set_long_option (arg); }
+
+/*------------------------------------------------------------------------*/
+
+bool App::most_likely_existing_cnf_file (const char * path)
+{
+  if (!File::exists (path)) return false;
+
+  if (has_suffix (path, ".dimacs")) return true;
+  if (has_suffix (path, ".dimacs.gz")) return true;
+  if (has_suffix (path, ".dimacs.xz")) return true;
+  if (has_suffix (path, ".dimacs.bz2")) return true;
+  if (has_suffix (path, ".dimacs.7z")) return true;
+  if (has_suffix (path, ".dimacs.lzma")) return true;
+
+  if (has_suffix (path, ".cnf")) return true;
+  if (has_suffix (path, ".cnf.gz")) return true;
+  if (has_suffix (path, ".cnf.xz")) return true;
+  if (has_suffix (path, ".cnf.bz2")) return true;
+  if (has_suffix (path, ".cnf.7z")) return true;
+  if (has_suffix (path, ".cnf.lzma")) return true;
+
+  return false;
+}
 
 /*------------------------------------------------------------------------*/
 
 // Short-cut for errors to avoid a hard 'exit'.
 
 #define APPERR(...) \
-do { solver->error (__VA_ARGS__); } while (0)
+do { root->error (__VA_ARGS__); } while (0)
 
 /*------------------------------------------------------------------------*/
 
 int App::main (int argc, char ** argv) {
-  const char * proof_path = 0, * solution_path = 0, * dimacs_path = 0;
-  const char * output_path = 0, * extension_path = 0, * config = 0;
-  int i, res = 0, optimize = 0, preprocessing = 0, localsearch = 0;
-  bool proof_specified = false, dimacs_specified = false;
-  int conflict_limit = -1, decision_limit = -1;
-  bool witness = true, less = false;
-  const char * dimacs_name, * err;
-  for (i = 1; i < argc; i++) {
-    if (!strcmp (argv[i], "-h")) {
+
+  // Handle options which lead to immediate exit first.
+
+  if (argc == 2) {
+    const char * arg = argv[1];
+    if (!strcmp (arg, "-h")) {
       print_usage ();
       return 0;
-    } else if (!strcmp (argv[i], "--help")) {
+    } else if (!strcmp (arg, "--help")) {
       print_usage (true);
       return 0;
-    } else if (!strcmp (argv[i], "--version")) {
+    } else if (!strcmp (arg, "--version")) {
       printf ("%s\n", CaDiCaL::version ());
       return 0;
-    } else if (!strcmp (argv[i], "--build")) {
+    } else if (!strcmp (arg, "--build")) {
       tout.disable ();
       Solver::build (stdout, "");
       return 0;
-    } else if (!strcmp (argv[i], "--copyright")) {
+    } else if (!strcmp (arg, "--copyright")) {
       printf ("%s\n", copyright ());
       return 0;
+    }
+  }
+
+  // Now initialize root solver.
+
+  init ();
+
+  // Set all argument option values to not used yet.
+
+  const char * preprocessing_specified = 0, * optimization_specified = 0;
+  const char * proof_path = 0, * solution_path = 0, * dimacs_path = 0;
+  const char * parallel_specified = 0, * threads_specified = 0;
+  const char * depth_specified = 0, * localsearch_specified = 0;
+  bool proof_specified = false, dimacs_specified = false;
+  int optimize = 0, preprocessing = 0, localsearch = 0;
+  const char * output_path = 0, * extension_path = 0;
+  int conflict_limit = -1, decision_limit = -1;
+  const char * conflict_limit_specified = 0;
+  const char * decision_limit_specified = 0;
+  const char * time_limit_specified = 0;
+  bool witness = true, less = false;
+  const char * dimacs_name, * err;
+
+  for (int i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h") ||
+        !strcmp (argv[i], "--help") ||
+        !strcmp (argv[i], "--build") ||
+        !strcmp (argv[i], "--version") ||
+        !strcmp (argv[i], "--copyright")) {
+      APPERR ("can only use '%s' as single first option", argv[i]);
     } else if (!strcmp (argv[i], "-")) {
       if (proof_specified) APPERR ("too many arguments");
       else if (!dimacs_specified) dimacs_specified = true;
@@ -251,11 +437,19 @@ int App::main (int argc, char ** argv) {
         APPERR ("multiple solution file options '-s %s' and '-s %s'",
           solution_path, argv[i]);
       else solution_path = argv[i];
+    } else if (!strcmp (argv[i], "-p")) {
+      APPERR ("invalid option '-p' (not implemented yet)");
+      if (parallel_specified) APPERR ("multiple '-p' options");
+      parallel_specified = argv[i];
     } else if (!strcmp (argv[i], "-o")) {
       if (++i == argc) APPERR ("argument to '-o' missing");
       else if (output_path)
         APPERR ("multiple output file options '-o %s' and '-o %s'",
           output_path, argv[i]);
+      else if (!force_writing &&
+               most_likely_existing_cnf_file (output_path))
+        APPERR ("output file '%s' most likely existing CNF (use '-f')",
+          output_path);
       else if (!File::writable (argv[i]))
         APPERR ("output file '%s' not writable", argv[i]);
       else output_path = argv[i];
@@ -264,6 +458,10 @@ int App::main (int argc, char ** argv) {
       else if (extension_path)
         APPERR ("multiple extension file options '-e %s' and '-e %s'",
           extension_path, argv[i]);
+      else if (!force_writing &&
+               most_likely_existing_cnf_file (extension_path))
+        APPERR ("extension file '%s' most likely existing CNF (use '-f')",
+          extension_path);
       else if (!File::writable (argv[i]))
         APPERR ("extension file '%s' not writable", argv[i]);
       else extension_path = argv[i];
@@ -289,36 +487,39 @@ int App::main (int argc, char ** argv) {
       else less = true;
     } else if (!strcmp (argv[i], "-c")) {
       if (++i == argc) APPERR ("argument to '-c' missing");
-      else if (conflict_limit >= 0)
-        APPERR ("multiple conflict limit options '-c %d' and '-c %s'",
-          conflict_limit, argv[i]);
+      else if (conflict_limit_specified)
+        APPERR ("multiple conflict limits '-c %s' and '-c %s'",
+          conflict_limit_specified, argv[i]);
       else if (!parse_int_str (argv[i], conflict_limit))
         APPERR ("invalid argument in '-c %s'", argv[i]);
       else if (conflict_limit < 0)
         APPERR ("invalid conflict limit");
+      else conflict_limit_specified = argv[i];
     } else if (!strcmp (argv[i], "-d")) {
       if (++i == argc) APPERR ("argument to '-d' missing");
-      else if (decision_limit >= 0)
-        APPERR ("multiple decision limit options '-d %d' and '-d %s'",
-          decision_limit, argv[i]);
+      else if (decision_limit_specified)
+        APPERR ("multiple decision limits '-d %s' and '-d %s'",
+          decision_limit_specified, argv[i]);
       else if (!parse_int_str (argv[i], decision_limit))
         APPERR ("invalid argument in '-d %s'", argv[i]);
       else if (decision_limit < 0)
         APPERR ("invalid decision limit");
+      else decision_limit_specified = argv[i];
     } else if (!strcmp (argv[i], "-t")) {
       if (++i == argc) APPERR ("argument to '-t' missing");
-      else if (time_limit >= 0)
-        APPERR ("multiple time limit options '-t %d' and '-t %s'",
-          time_limit, argv[i]);
+      else if (time_limit_specified)
+        APPERR ("multiple time limit '-t %s' and '-t %s'",
+          time_limit_specified, argv[i]);
       else if (!parse_int_str (argv[i], time_limit))
         APPERR ("invalid argument in '-d %s'", argv[i]);
       else if (time_limit < 0)
         APPERR ("invalid time limit");
+      else time_limit_specified = argv[i];
     }
 #ifndef QUIET
     else if (!strcmp (argv[i], "-q")) set ("--quiet");
     else if (!strcmp (argv[i], "-v"))
-      solver->set ("verbose", get ("verbose") + 1);
+      set ("verbose", get ("verbose") + 1);
 #endif
 #ifdef LOGGING
     else if (!strcmp (argv[i], "-l")) set ("--log");
@@ -326,44 +527,118 @@ int App::main (int argc, char ** argv) {
     else if (!strcmp (argv[i], "-f") ||
              !strcmp (argv[i], "--force") ||
              !strcmp (argv[i], "--force=1") ||
-             !strcmp (argv[i], "--force=true")) strict = 0;
+             !strcmp (argv[i], "--force=true"))
+      force_strict_parsing = 0,
+      force_writing = true;
     else if (!strcmp (argv[i], "--strict") ||
              !strcmp (argv[i], "--strict=1") ||
-             !strcmp (argv[i], "--strict=true")) strict = 2;
-    else if (argv[i][0] == '-' && argv[i][1] == 'O') {
-      if (!parse_int_str (argv[i] + 2, optimize) ||
-          optimize < 0 || optimize > 31)
-        APPERR ("invalid optimization option '%s' (expected '-O[0..31]')",
+             !strcmp (argv[i], "--strict=true"))
+      force_strict_parsing = 2;
+    else if (has_prefix (argv[i], "-O")) {
+      if (optimization_specified)
+        APPERR ("multiple optimization options '%s' and '%s'",
+          optimization_specified, argv[i]);
+      optimization_specified = argv[i];
+      if (!parse_int_str (argv[i] + 2, optimize))
+        APPERR ("invalid optimization option '%s'", argv[i]);
+      if (optimize < 0 || optimize > 31)
+        APPERR ("invalid argument in '%s' (expected '0..31')", argv[i]);
+    } else if (has_prefix (argv[i], "-P")) {
+      if (preprocessing_specified)
+        APPERR ("multiple preprocessing options '%s' and '%s'",
+          preprocessing_specified, argv[i]);
+      preprocessing_specified = argv[i];
+      if (!parse_int_str (argv[i] + 2, preprocessing))
+        APPERR ("invalid preprocessing option '%s'", argv[i]);
+      if (preprocessing < 0)
+        APPERR ("invalid argument in '%s' (expected non-negative number)",
           argv[i]);
-    } else if (argv[i][0] == '-' && argv[i][1] == 'P') {
-      if (!parse_int_str (argv[i] + 2, preprocessing) || preprocessing < 0)
-        APPERR ("invalid preprocessing option '%s' (expected '-P<int>')",
+    } else if (has_prefix (argv[i], "-L")) {
+      if (localsearch_specified)
+        APPERR ("multiple local search options '%s' and '%s'",
+          localsearch_specified, argv[i]);
+      localsearch_specified = argv[i];
+      if (!parse_int_str (argv[i] + 2, localsearch))
+        APPERR ("invalid local search option '%s'", argv[i]);
+      if (localsearch < 0)
+        APPERR ("invalid argument in '%s' (expected non-negative number)",
           argv[i]);
-    } else if (argv[i][0] == '-' && argv[i][1] == 'L') {
-      if (!parse_int_str (argv[i] + 2, localsearch) || localsearch < 0)
-        APPERR ("invalid local search option '%s' (expected '-L<int>')",
+    } else if (has_prefix (argv[i], "-D")) {
+      if (depth_specified)
+        APPERR ("multiple depth options '%s' and '%s'",
+          depth_specified, argv[i]);
+      depth_specified = argv[i];
+      if (!parse_int_str (argv[i] + 2, max_depth))
+        APPERR ("invalid depth option '%s'", argv[i]);
+      if (max_depth <= 0)
+        APPERR ("invalid argument in '%s' (expected positive number)",
           argv[i]);
-    } else if (argv[i][0] == '-' && argv[i][1] == '-' &&
-               solver->is_valid_configuration (argv[i] + 2)) {
-      if (config)
-         APPERR ("can not use two configurations '--%s' and '%s'",
-           config, argv[i]);
-      config = argv[i] + 2;
-    } else if (set (argv[i])) { /* nothing do be done */ }
-    else if (argv[i][0] == '-') APPERR ("invalid option '%s'", argv[i]);
+    } else if (has_prefix (argv[i], "-S") || has_prefix (argv[i], "-T")) {
+      APPERR ("invalid option '%s' (not implemented yet)", argv[i]);
+    } else if (has_prefix (argv[i], "--") &&
+               root->is_valid_configuration (argv[i] + 2)) {
+      root->configure (argv[i] + 2);
+    } else if (set (argv[i])) {
+      /* nothing do be done */
+    } else if (argv[i][0] == '-') APPERR ("invalid option '%s'", argv[i]);
     else if (proof_specified) APPERR ("too many arguments");
     else if (dimacs_specified) {
-      if (!File::writable (argv[i]))
-        APPERR ("DRAT proof file '%s' not writable", argv[i]);
-      proof_specified = true;
       proof_path = argv[i];
+      proof_specified = true;
+      if (!force_writing &&
+          most_likely_existing_cnf_file (proof_path))
+        APPERR ("DRAT proof file '%s' most likely existing CNF (use '-f')",
+          proof_path);
+      else if (!File::writable (proof_path))
+        APPERR ("DRAT proof file '%s' not writable", proof_path);
     } else dimacs_specified = true, dimacs_path = argv[i];
   }
 
-  // The '--less' option is not fully functional yet.  It only works as
-  // expected if you let the solver run until it exits.  The goal is to have
-  // a similar experience as the default with 'git diff' if the terminal is
-  // too small for the message.
+  /*----------------------------------------------------------------------*/
+
+  if (dimacs_specified && dimacs_path && !File::exists (dimacs_path))
+    APPERR ("DIMACS input file '%s' does not exist", dimacs_path);
+  if (solution_path && !File::exists (solution_path))
+    APPERR ("solution file '%s' does not exist", solution_path);
+  if (dimacs_specified && dimacs_path &&
+      proof_specified && proof_path &&
+      !strcmp (dimacs_path, proof_path) && strcmp (dimacs_path, "-"))
+    APPERR ("DIMACS input file '%s' also specified as DRAT proof file",
+      dimacs_path);
+
+  /*----------------------------------------------------------------------*/
+
+  const char * multiple_specified;
+       if (parallel_specified) multiple_specified = parallel_specified;
+  else if (threads_specified)  multiple_specified = threads_specified;
+  else if (depth_specified)    multiple_specified = depth_specified;
+  else                         multiple_specified = 0;
+
+  if (multiple_specified) {
+    multiple = true;
+    if (output_path)
+      APPERR ("can not combine '%s' and writing CNF with '-o %s'",
+        multiple_specified, output_path);
+    if (extension_path)
+      APPERR ("can not combine '%s' and writing extension with '-e %s'",
+        multiple_specified, extension_path);
+    if (proof_specified)
+      APPERR ("can not combine '%s' and writing proof to '%s'",
+        multiple_specified, proof_path ? proof_path : "<stdout>");
+    if (conflict_limit_specified)
+      APPERR ("can not combine '%s' and '-c %s'",
+        multiple_specified, conflict_limit_specified);
+    if (decision_limit_specified)
+      APPERR ("can not combine '%s' and '-d %s'",
+        multiple_specified, decision_limit_specified);
+  }
+
+  /*----------------------------------------------------------------------*/
+  // The '--less' option is not fully functional yet (it is also not
+  // mentioned in the 'usage' message yet).  It only works as expected if
+  // you let the solver run until it exits.  The goal is to have a similar
+  // experience as with 'git diff' if the terminal is too small for the
+  // printed messages, but this needs substantial hacking.
   //
   // TODO: add proper forking, waiting, signal catching & propagating ...
   //
@@ -376,88 +651,92 @@ int App::main (int argc, char ** argv) {
     dup2 (fileno (less_pipe), 1);
   } else less_pipe = 0;
 
-  if (dimacs_specified && dimacs_path && !File::exists (dimacs_path))
-    APPERR ("DIMACS input file '%s' does not exist", dimacs_path);
-  if (solution_path && !File::exists (solution_path))
-    APPERR ("solution file '%s' does not exist", solution_path);
-  if (dimacs_specified && dimacs_path &&
-      proof_specified && proof_path &&
-      !strcmp (dimacs_path, proof_path) && strcmp (dimacs_path, "-"))
-    APPERR ("DIMACS input file '%s' also specified as DRAT proof file",
-      dimacs_path);
+  /*----------------------------------------------------------------------*/
+
   if (solution_path && !get ("check")) set ("--check");
 #ifndef QUIET
   if (!get ("quiet")) {
-    solver->section ("banner");
-    solver->message ("%sCaDiCaL Radically Simplified CDCL SAT Solver%s",
+    root->section ("banner");
+    root->message ("%sCaDiCaL Radically Simplified CDCL SAT Solver%s",
       tout.bright_magenta_code (), tout.normal_code ());
-    solver->message ("%s%s%s",
+    root->message ("%s%s%s",
       tout.bright_magenta_code (), copyright (), tout.normal_code ());
-    solver->message ();
+    root->message ();
     CaDiCaL::Solver::build (stdout, "c ");
   }
 #endif
-  if (config) {
-    solver->section ("config");
-    assert (Config::has (config));
-    solver->message ("using '%s' configuration (%s)",
-      config, Config::description (config));
-    solver->configure (config);
-  }
   if (preprocessing > 0 || localsearch > 0 ||
       time_limit >= 0 || conflict_limit >= 0 || decision_limit >= 0) {
-    solver->section ("limit");
+    root->section ("limit");
     if (preprocessing > 0) {
-      solver->message (
-        "enabling %d initial rounds of preprocessing", preprocessing);
-      solver->limit ("preprocessing", preprocessing);
+      root->message (
+        "enabling %d initial rounds of preprocessing (due to '%s')",
+        preprocessing, preprocessing_specified);
+      root->limit ("preprocessing", preprocessing);
     }
     if (localsearch > 0) {
-      solver->message (
-        "enabling %d initial rounds of local search", localsearch);
-      solver->limit ("localsearch", localsearch);
+      root->message (
+        "enabling %d initial rounds of local search (due to '%s')",
+        localsearch, localsearch_specified);
+      root->limit ("localsearch", localsearch);
     }
     if (time_limit >= 0) {
-      solver->message (
-        "setting time limit to %d seconds real time",
-        time_limit);
+      root->message (
+        "setting time limit to %d seconds real time (due to '-t %s')",
+        time_limit, time_limit_specified);
       Signal::alarm (time_limit);
-      solver->connect_terminator (this);
+      root->connect_terminator (this);
     }
     if (conflict_limit >= 0) {
-      solver->message ("setting conflict limit to %d conflicts",
-        conflict_limit);
-      bool succeeded = solver->limit ("conflicts", conflict_limit);
+      root->message (
+        "setting conflict limit to %d conflicts (due to '%s')",
+        conflict_limit, conflict_limit_specified);
+      bool succeeded = root->limit ("conflicts", conflict_limit);
       assert (succeeded), (void) succeeded;
     }
     if (decision_limit >= 0) {
-      solver->message ("setting decision limit to %d decisions",
-        decision_limit);
-      bool succeeded = solver->limit ("decisions", decision_limit);
+      root->message (
+        "setting decision limit to %d decisions (due to '%s')",
+        decision_limit, decision_limit_specified);
+      bool succeeded = root->limit ("decisions", decision_limit);
       assert (succeeded), (void) succeeded;
     }
   }
-  if (verbose () || proof_specified) solver->section ("proof tracing");
+  if (multiple) {
+    root->section ("multiple");
+    if (depth_specified)
+      root->message ("maximum depth %d (due to '%s')",
+        max_depth, depth_specified);
+#if 0
+    if (parallel_specified)
+      root->message ("parallel solving specified (due to '%s')",
+        parallel_specified);
+    if (threads_specified)
+      root->message ("maximum number of threads '%d' (due to '%s')",
+        max_threads, threads_specified);
+#endif
+  }
+  if (verbose () || proof_specified) root->section ("proof tracing");
   if (proof_specified) {
     if (!proof_path) {
       const bool force_binary = (isatty (1) && get ("binary"));
       if (force_binary) set ("--no-binary");
-      solver->message ("writing %s proof trace to %s'<stdout>'%s",
+      root->message ("writing %s proof trace to %s'<stdout>'%s",
         (get ("binary") ? "binary" : "non-binary"),
         tout.green_code (), tout.normal_code ());
       if (force_binary)
-        solver->message (
+        root->message (
           "connected to terminal thus non-binary proof forced");
-      solver->trace_proof (stdout, "<stdout>");
-    } else if (!solver->trace_proof (proof_path))
+      root->trace_proof (stdout, "<stdout>");
+    } else if (!root->trace_proof (proof_path))
       APPERR ("can not open and write DRAT proof to '%s'", proof_path);
     else
-      solver->message (
+      root->message (
         "writing %s proof trace to %s'%s'%s",
         (get ("binary") ? "binary" : "non-binary"),
         tout.green_code (), proof_path, tout.normal_code ());
-  } else solver->verbose (1, "will not generate nor write DRAT proof");
-  solver->section ("parsing input");
+  } else root->verbose (1, "will not generate nor write DRAT proof");
+  root->section ("parsing input");
   dimacs_name = dimacs_path ? dimacs_path : "<stdin>";
   string help;
   if (!dimacs_path) {
@@ -466,52 +745,187 @@ int App::main (int argc, char ** argv) {
     help += "(use '-h' for a list of common options)";
     help += tout.normal_code ();
   }
-  solver->message ("reading DIMACS file from %s'%s'%s%s",
+  root->message ("reading DIMACS file from %s'%s'%s%s",
     tout.green_code (), dimacs_name, tout.normal_code (), help.c_str ());
+  bool incremental;
+  vector<int> cube_literals;
   if (dimacs_path)
-       err = solver->read_dimacs (dimacs_path, max_var, strict);
-  else err = solver->read_dimacs (stdin, dimacs_name, max_var, strict);
+    err = root->read_dimacs(dimacs_path, max_var, force_strict_parsing,
+                            incremental, cube_literals);
+  else
+    err = root->read_dimacs(stdin, dimacs_name, max_var, force_strict_parsing,
+                            incremental, cube_literals);
   if (err) APPERR ("%s", err);
   if (solution_path) {
-    solver->section ("parsing solution");
-    solver->message ("reading solution file from '%s'", solution_path);
-    if ((err = solver->read_solution (solution_path)))
+    root->section ("parsing solution");
+    root->message ("reading solution file from '%s'", solution_path);
+    if ((err = root->read_solution (solution_path)))
       APPERR ("%s", err);
   }
 
-  solver->section ("options");
+#if 0
+  root->section ("resources");
+  (void) number_of_cores (root->internal);
+  root->message ();
+  (void) memory_limit (root->internal);
+#endif
+
+  root->section ("options");
   if (optimize > 0) {
-    solver->optimize (optimize);
-    solver->message ();
+    root->optimize (optimize);
+    root->message ();
   }
-  solver->options ();
+  root->options ();
 
-  solver->section ("solving");
-  res = solver->solve ();
+  int res = 0;
+
+  if (incremental) {
+    bool reporting = get ("report") > 1 || get ("verbose") > 0;
+    if (!reporting) set ("report", 0);
+    if (!reporting) root->section ("incremental solving");
+    size_t cubes = 0, solved = 0;
+    size_t satisfiable = 0, unsatisfiable = 0, inconclusive = 0;
+#ifndef QUIET
+    bool quiet = get ("quiet");
+    struct { double start, delta, sum; } time = { 0, 0, 0 };
+#endif
+    for (auto lit : cube_literals)
+      if (!lit)
+	cubes++;
+    if (!reporting) {
+    if (cubes)
+      root->message ("starting to solve %zu cubes", cubes),
+      root->message ();
+    else
+      root->message ("no cube to solve");
+    }
+    vector<int> cube, failed;
+    for (auto lit : cube_literals) {
+      if (lit) cube.push_back (lit);
+      else {
+	reverse (cube.begin (), cube.end ());
+	for (auto other : cube)
+	  root->assume (other);
+	if (solved++) {
+	  if (conflict_limit >= 0)
+	    (void) root->limit ("conflicts", conflict_limit);
+	  if (decision_limit >= 0)
+	    (void) root->limit ("decisions", decision_limit);
+	}
+#ifndef QUIET
+	char buffer[160];
+	if (!quiet) {
+	  if (reporting) {
+	    sprintf (buffer, "solving cube %zu / %zu %.0f%%",
+	       solved, cubes, percent (solved, cubes));
+	    root->section (buffer);
+	  }
+	  time.start = absolute_process_time ();
+	}
+#endif
+	res = root->solve ();
+#ifndef QUIET
+	if (!quiet) {
+	  time.delta = absolute_process_time () - time.start;
+	  time.sum += time.delta;
+	  sprintf (buffer,
+	    "%s"
+	    "in %.3f sec "
+	    "(%.0f%% after %.2f sec at %.0f ms/cube)"
+	    "%s",
+	    tout.magenta_code (),
+	    time.delta,
+	    percent (solved, cubes),
+	    time.sum,
+	    relative (1e3*time.sum, solved),
+	    tout.normal_code ());
+	  if (reporting)
+	    root->message ();
+	  const char * cube_str, * status_str, * color_code;
+	  if (res == 10) {
+	    cube_str = "CUBE";
+	    color_code = tout.green_code ();
+	    status_str = "SATISFIABLE";
+	  } else if (res == 20) {
+	    cube_str = "CUBE";
+	    color_code = tout.cyan_code ();
+	    status_str = "UNSATISFIABLE";
+	  } else {
+	    cube_str = "cube";
+	    color_code = tout.magenta_code ();
+	    status_str = "inconclusive";
+	  }
+	  const char * fmt;
+	  if (reporting) fmt = "%s%s %zu %s%s %s";
+	  else           fmt = "%s%s %zu %-13s%s %s";
+	  root->message (fmt,
+	    color_code, cube_str, solved, status_str, 
+	    tout.normal_code (), buffer);
+	}
+#endif
+	if (res == 10) {
+	  satisfiable++;
+	  break;
+	} else if (res == 20) {
+	  unsatisfiable++;
+	  for (auto other : cube)
+	    if (root->failed (other))
+	      failed.push_back (other);
+	  for (auto other : failed)
+	    root->add (-other);
+	  root->add (0);
+	  failed.clear ();
+	} else {
+	  assert (!res);
+	  inconclusive++;
+	  if (timesup)
+	    break;
+	}
+	cube.clear ();
+      }
+    }
+    root->section ("incremental summary");
+    root->message ("%zu cubes solved %.0f%%",
+      solved, percent (solved, cubes));
+    root->message ("%zu cubes inconclusive %.0f%%",
+      inconclusive, percent (inconclusive, solved));
+    root->message ("%zu cubes unsatisfiable %.0f%%",
+      unsatisfiable, percent (unsatisfiable, solved));
+    root->message ("%zu cubes satisfiable %.0f%%",
+      satisfiable, percent (satisfiable, solved));
+
+    if (inconclusive && res == 20)
+      res = 0;
+  } else {
+    root->section ("solving");
+    res = root->solve ();
+  }
+
+  if (res == 10) winner = root;
 
   if (proof_specified) {
-    solver->section ("closing proof");
-    solver->flush_proof_trace ();
-    solver->close_proof_trace ();
+    root->section ("closing proof");
+    root->flush_proof_trace ();
+    root->close_proof_trace ();
   }
 
   if (output_path) {
-    solver->section ("writing output");
-    solver->message ("writing simplified CNF to DIMACS file %s'%s'%s",
+    root->section ("writing output");
+    root->message ("writing simplified CNF to DIMACS file %s'%s'%s",
       tout.green_code (), output_path, tout.normal_code ());
-    err = solver->write_dimacs (output_path, max_var);
+    err = root->write_dimacs (output_path, max_var);
     if (err) APPERR ("%s", err);
   }
 
   if (extension_path) {
-    solver->section ("writing extension");
-    solver->message ("writing extension stack to %s'%s'%s",
+    root->section ("writing extension");
+    root->message ("writing extension stack to %s'%s'%s",
       tout.green_code (), extension_path, tout.normal_code ());
-    err = solver->write_extension (extension_path);
+    err = root->write_extension (extension_path);
     if (err) APPERR ("%s", err);
   }
 
-  solver->section ("result");
+  root->section ("result");
   if (res == 10) {
     printf ("s SATISFIABLE\n");
     if (witness) {
@@ -521,33 +935,69 @@ int App::main (int argc, char ** argv) {
   } else if (res == 20) printf ("s UNSATISFIABLE\n");
   else printf ("c UNKNOWN\n");
   fflush (stdout);
-  solver->statistics ();
-  solver->section ("shutting down");
-  solver->message ("exit %d", res);
+  root->statistics ();
+  if (multiple) root->prefix ("c ");
+  root->resources ();
+  root->section ("shutting down");
+  root->message ("exit %d", res);
   if (less_pipe) {
     close (1);
     pclose (less_pipe);
   }
+
   return res;
 }
 
-App::App () :
-  time_limit (-1), max_var (0), strict (1), timesup (false)
-{
-  CaDiCaL::Options::report_default_value = 1;
-  solver = new Solver;
+/*------------------------------------------------------------------------*/
+
+// The real initialization is delayed.
+
+void App::init () {
+
+  assert (!root);
+
+  winner = 0;
+  multiple = false;
+  // parallel = false;
+  max_depth = 0;
+  // max_threads = 0;
+  // max_solvers = 0;
+  time_limit = -1;
+  force_strict_parsing = 1;
+  force_writing = false;
+  max_var = 0;
+  timesup = false;
+
+  memset (&stats, 0, sizeof stats);
+
+  // Call 'new Solver' only after setting 'reportdefault' and do not
+  // add this call to the member initialization above. This is because for
+  // stand-alone usage the default report default value is 'true' while for
+  // library usage it should remain 'false'.  See the explanation in
+  // 'options.hpp' related to 'reportdefault' for details.
+
+  CaDiCaL::Options::reportdefault = 1;
+  initialize_root ();
   Signal::set (this);
 }
 
+/*------------------------------------------------------------------------*/
+
+App::App () : root (0) { }      // Only partially initialize the app.
+
 App::~App () {
+  if (!root) return;            // Only partially initialized.
   Signal::reset ();
-  delete solver;
+  for (auto & job : jobs)
+    delete job;
 }
 
+/*------------------------------------------------------------------------*/
+
 #ifndef QUIET
 
 void App::signal_message (const char * msg, int sig) {
-  solver->message (
+  root->message (
     "%s%s %ssignal %d%s (%s)%s",
     tout.red_code (), msg,
     tout.bright_red_code (), sig,
@@ -560,12 +1010,14 @@ void App::signal_message (const char * msg, int sig) {
 void App::catch_signal (int sig) {
 #ifndef QUIET
   if (!get ("quiet")) {
-    solver->message ();
+    root->message ();
     signal_message ("caught", sig);
-    solver->section ("result");
-    solver->message ("UNKNOWN");
-    solver->statistics ();
-    solver->message ();
+    root->section ("result");
+    root->message ("UNKNOWN");
+    root->statistics ();
+    if (multiple) root->prefix ("c ");
+    root->resources ();
+    root->message ();
     signal_message ("raising", sig);
   }
 #else
@@ -574,15 +1026,24 @@ void App::catch_signal (int sig) {
 }
 
 void App::catch_alarm () {
-
   // Both approaches work. We keep them here for illustration purposes.
-  //
-  // solver->terminate (); // immediate asynchronous call into solver
-  timesup = true;          // wait for solver to call 'App::terminate ()'
+#if 0 // THIS IS AN ALTERNATIVE WE WANT TO KEEP AROUND.
+  root->terminate (); // immediate asynchronous call into solver
+#else
+  timesup = true;       // wait for solver to call 'App::terminate ()'
+#endif
 }
 
 } // end of 'namespace CaDiCaL'
 
+/*------------------------------------------------------------------------*/
+
+// The actual app is allocated on the stack and then its 'main' function is
+// called.  This looks like that there are no static variables, which is not
+// completely true, since both the signal handler connected to the app as
+// well as the terminal have statically allocated components as well as the
+// options table 'Options::table'.  All are shared among solvers.
+
 int main (int argc, char ** argv) {
   CaDiCaL::App app;
   return app.main (argc, argv);
diff --git a/src/cadical.hpp b/src/cadical.hpp
index 62f7a93d..b681260a 100644
--- a/src/cadical.hpp
+++ b/src/cadical.hpp
@@ -133,25 +133,27 @@ namespace CaDiCaL {
 //               terminate (asynchronously)
 //      SOLVING  ------------------------->  UNKNOWN
 //
-// The main restriction to remember is that adding or assuming a literal
-// immediately destroys the satisfying assignment in the 'SATISFIED' state
-// and vice versa resets all assumptions in the 'UNSATISFIED' state.
-//
-// Further the model can only be queried through 'val' in the 'SATISFIED'
-// state, while extracting failed assumptions with 'val' only in the
-// 'UNSATISFIED' state.  Solving can only be started in the 'UNKNOWN' or
-// 'CONFIGURING' state or after the previous call to 'solve' yields an
+// The important behaviour to remember is that adding or assuming a literal
+// (immediately) destroys the satisfying assignment in the 'SATISFIED' state
+// and vice versa resets all assumptions in the 'UNSATISFIED' state.  This
+// is exactly the behaviour required by the IPASIR interface.
+//
+// Furthermore, the model can only be queried through 'val' in the
+// 'SATISFIED' state, while extracting failed assumptions with 'val' only in
+// the 'UNSATISFIED' state.  Solving can only be started in the 'UNKNOWN' or
+// 'CONFIGURING' state or after the previous call to 'solve' yielded an
 // 'UNKNOWN, 'SATISFIED' or 'UNSATISFIED' state.
 //
 // All literals have to be valid literals too, i.e., 32-bit integers
 // different from 'INT_MIN'.  If any of these requirements is violated the
-// solver aborts with an 'API contract violation' message.  If you do not
-// understand why the contract is violated you can run 'mobical' on the
-// failing API call trace.  Point the environment variable
+// solver aborts with an 'API contract violation' message.
+//
+// HINT: If you do not understand why a contract is violated you can run
+// 'mobical' on the failing API call trace.  Point the environment variable
 // 'CADICAL_API_TRACE' to the file where you want to save the trace during
-// execution of the library.  You might need for 'mobical' to use the option
-// '--do-not-enforce-contracts' though to force running into the same
-// contract violation.
+// execution of your program linking against the library.  You probably need
+// for 'mobical' to use the option '--do-not-enforce-contracts' though to
+// force running into the same contract violation.
 //
 // Additional API calls (like 'freeze' and 'melt') do not change the state
 // of the solver and are all described below.
@@ -180,7 +182,7 @@ enum State
 
 /*------------------------------------------------------------------------*/
 
-// Opaque classes declared in the same namespace needed in the API.
+// Opaque classes needed in the API and declared in the same namespace.
 
 class File;
 struct Internal;
@@ -190,6 +192,7 @@ struct External;
 
 // Forward declaration of call-back classes. See bottom of this file.
 
+class Learner;
 class Terminator;
 class ClauseIterator;
 class WitnessIterator;
@@ -222,7 +225,9 @@ class Solver {
   //
   void add (int lit);
 
-  // Assume valid non zero literal for next call to 'solve'.
+  // Assume valid non zero literal for next call to 'solve'.  These
+  // assumptions are reset after the call to 'solve' as well as after
+  // returning from 'simplify' and 'lookahead.
   //
   //   require (READY)
   //   ensure (UNKNOWN)
@@ -261,8 +266,8 @@ class Solver {
   //
   bool failed (int lit);
 
-  // Add call-back which is check regularly for termination.  There can only
-  // be one terminator be connected.  If a second (non-zero) one is added
+  // Add call-back which is checked regularly for termination.  There can
+  // only be one terminator connected.  If a second (non-zero) one is added
   // the first one is implicitly disconnected.
   //
   //   require (VALID)
@@ -271,28 +276,69 @@ class Solver {
   void connect_terminator (Terminator * terminator);
   void disconnect_terminator ();
 
+  // Add call-back which allows to export learned clauses.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void connect_learner (Learner * learner);
+  void disconnect_learner ();
+
   // ====== END IPASIR =====================================================
 
+  //------------------------------------------------------------------------
+  // This function determines a good splitting literal.  The result can be
+  // zero if the formula is proven to be satisfiable or unsatisfiable.  This
+  // can then be checked by 'state ()'.  If the formula is empty and
+  // the function is not able to determine satisfiability also zero is
+  // returned but the state remains unknown.
+  //
+  //   require (READY)
+  //   ensure (UNKNOWN|SATISFIED|UNSATISFIED)
+  //
+  int lookahead(void);
+
+  struct CubesWithStatus {
+    int status;
+    std::vector<std::vector<int>> cubes;
+  };
+
+  CubesWithStatus generate_cubes(int);
+
+  void reset_assumptions();
+
   // Return the current state of the solver as defined above.
   //
   const State & state () const { return _state; }
 
+  // Similar to 'state ()' but using the staddard competition exit codes of
+  // '10' for 'SATISFIABLE', '20' for 'UNSATISFIABLE' and '0' otherwise.
+  //
+  int status () const {
+         if (_state == SATISFIED)   return 10;
+    else if (_state == UNSATISFIED) return 20;
+    else                            return 0;
+  }
+
   /*----------------------------------------------------------------------*/
 
   static const char * version ();    // return version string
 
   /*----------------------------------------------------------------------*/
-  // The copy constructor is not a deep clone, but only copies irredundant
-  // clauses and makes sure that witness reconstruction works with the copy
-  // as with the original formula.  Both have the same models.  Assumptions
-  // are not copied.
+  // Copy 'this' into a fresh 'other'.  The copy procedure is not a deep
+  // clone, but only copies irredundant clauses and units.  It also makes
+  // sure that witness reconstruction works with the copy as with the
+  // original formula such that both solvers have the same models.
+  // Assumptions are not copied.  Options however are copied as well as
+  // flags which remember the current state of variables in preprocessing.
   //
-  //   require (READY)
-  //   ensure (READY)
+  //   require (READY)          // for 'this'
+  //   ensure (READY)           // for 'this'
   //
-  // (for both this solver and its copy)
+  //   other.require (CONFIGURING)
+  //   other.ensure (CONFIGURING | UNKNOWN)
   //
-  void copy (Solver &) const;
+  void copy (Solver & other) const;
 
   /*----------------------------------------------------------------------*/
   // Variables are usually added and initialized implicitly whenever a
@@ -315,6 +361,7 @@ class Solver {
   //
   void reserve (int min_max_var);
 
+#ifndef NTRACING
   //------------------------------------------------------------------------
   // This function can be used to write API calls to a file.  The same
   // format is used which 'mobical' can read, execute and also shrink
@@ -334,6 +381,7 @@ class Solver {
   //   ensure (VALID)
   //
   void trace_api_calls (FILE * file);
+#endif
 
   //------------------------------------------------------------------------
   // Option handling.
@@ -342,6 +390,10 @@ class Solver {
   //
   static bool is_valid_option (const char * name);
 
+  // Determine whether 'name' enables a specific preprocessing technique.
+  //
+  static bool is_preprocessing_option (const char * name);
+
   // Determine whether 'arg' is a valid long option of the form '--<name>',
   // '--<name>=<val>' or '--no-<name>' similar to 'set_long_option' below.
   // Legal values are 'true', 'false', or '[-]<mantissa>[e<exponent>]'.
@@ -412,8 +464,11 @@ class Solver {
   // preprocessing rounds, which is zero by default.  Similarly, the local
   // search limit determines the number of local search rounds (also zero by
   // default).  As with 'set', the return value denotes whether the limit
-  // 'name' is valid.  These limits are only valid for the next 'solve' call
-  // and reset to their default after 'solve' returns.
+  // 'name' is valid.  These limits are only valid for the next 'solve' or
+  // 'simplify' call and reset to their default after 'solve' returns (as
+  // well as overwritten and reset during calls to 'simplify' and
+  // 'lookahead').  We actually also have an internal "terminate" limit
+  // which however should only be used for testing and debugging.
   //
   //   require (READY)
   //   ensure (READY)
@@ -436,8 +491,17 @@ class Solver {
   int64_t irredundant () const; // Number of active irredundant clauses.
 
   //------------------------------------------------------------------------
-  // Same as 'solve' with 'limits ("conflicts", 0)' and
-  //                      'limits ("preprocessing", rounds)'.
+  // This function executes the given number of preprocessing rounds. It is
+  // similar to 'solve' with 'limits ("preprocessing", rounds)' except that
+  // no CDCL nor local search, nor lucky phases are executed.  The result
+  // values are also the same: 0=unknown, 10=satisfiable, 20=unsatisfiable.
+  // As 'solve' it resets current assumptions and limits before returning.
+  // The numbers of rounds should not be negative.  If the number of rounds
+  // is zero only clauses are restored (if necessary) and top level unit
+  // propagation is performed, which both take some time.
+  //
+  //   require (READY)
+  //   ensure (UNKNOWN | SATISFIED | UNSATISFIED)
   //
   int simplify (int rounds = 3);
 
@@ -474,6 +538,8 @@ class Solver {
   // error message even if in principle the solver could just restore
   // clauses. Thus this option is disabled by default.
   //
+  // See our SAT'19 paper [FazekasBiereScholl-SAT'19] for more details.
+  //
   //   require (VALID)
   //   ensure (VALID)
   //
@@ -492,6 +558,12 @@ class Solver {
   //
   int fixed (int lit) const;
 
+  //------------------------------------------------------------------------
+  // Force the default decision phase of a variable to a certain value.
+  //
+  void phase (int lit);
+  void unphase (int lit);
+
   //------------------------------------------------------------------------
 
   // Enables clausal proof tracing in DRAT format and returns 'true' if
@@ -529,6 +601,7 @@ class Solver {
   //   ensure (!DELETING)
   //
   void statistics ();   // print statistics
+  void resources ();    // print resource usage (time and memory)
 
   //   require (VALID)
   //   ensure (VALID)
@@ -558,7 +631,7 @@ class Solver {
   // clauses specified in the DIMACS headers are ignored, i.e., the header
   // 'p cnf 0 0' is always legal.  If the 'strict' argument is larger '1'
   // strict formatting of the header is required, i.e., single spaces
-  // everywhere and no trailing white space. Default is 'strict == 1'.
+  // everywhere and no trailing white space.
   //
   // Returns zero if successful and otherwise an error message.
   //
@@ -566,8 +639,22 @@ class Solver {
   //   ensure (VALID)
   //
   const char * read_dimacs (FILE * file,
-                            const char * name, int & vars, int strict);
-  const char * read_dimacs (const char * path, int & vars, int strict);
+                            const char * name, int & vars, int strict = 1);
+
+  const char * read_dimacs (const char * path, int & vars, int strict = 1);
+
+  // The following routines work the same way but parse both DIMACS and
+  // INCCNF files (with 'p inccnf' header and 'a <cube>' lines).  If the
+  // parser finds and 'p inccnf' header or cubes then '*incremental' is set
+  // to true and the cubes are stored in the given vector (each cube
+  // terminated by a zero).
+
+  const char * read_dimacs (FILE * file,
+                            const char * name, int & vars, int strict,
+			    bool & incremental, std::vector<int> & cubes);
+
+  const char * read_dimacs (const char * path, int & vars, int strict,
+                            bool & incremental, std::vector<int> & cubes);
 
   //------------------------------------------------------------------------
   // Write current irredundant clauses and all derived unit clauses
@@ -595,6 +682,8 @@ class Solver {
 
 private:
 
+  //==== start of state ====================================================
+
   State _state;            // API states as discussed above.
 
   /*----------------------------------------------------------------------*/
@@ -636,6 +725,7 @@ class Solver {
   Internal * internal;     // Hidden internal solver.
   External * external;     // Hidden API to internal solver mapping.
 
+#ifndef NTRACING
   // The API calls to the solver can be traced by setting the environment
   // variable 'CADICAL_API_TRACE' to point to the path of a file to which
   // API calls are written. The same format is used which 'mobical' can
@@ -651,9 +741,12 @@ class Solver {
 
   static bool tracing_api_through_environment;
 
+  //===== end of state ====================================================
+
   void trace_api_call (const char *) const;
   void trace_api_call (const char *, int) const;
   void trace_api_call (const char *, const char *, int) const;
+#endif
 
   void transition_to_unknown_state ();
 
@@ -696,11 +789,13 @@ class Solver {
   //   require (VALID)
   //   ensure (VALID)
   //
-  const char * read_dimacs (File *, int &, int strict);
+  const char * read_dimacs (File *, int &, int strict,
+                            bool * incremental = 0,
+			    std::vector<int> * = 0);
 
-  // Factored out common code for 'solve' and 'simplify'.
+  // Factored out common code for 'solve', 'simplify' and 'lookahead'.
   //
-  int call_external_solve_and_check_results ();
+  int call_external_solve_and_check_results (bool preprocess_only);
 
   //------------------------------------------------------------------------
   // Print DIMACS file to '<stdout>' for debugging and testing purposes,
@@ -717,7 +812,9 @@ class Solver {
 
 /*========================================================================*/
 
-// Connected terminators are checked for termination regularly.
+// Connected terminators are checked for termination regularly.  If the
+// 'terminate' function of the terminator returns true the solver is
+// terminated synchronously as soon it calls this function.
 
 class Terminator {
 public:
@@ -725,15 +822,29 @@ class Terminator {
   virtual bool terminate () = 0;
 };
 
+// Connected learners which can be used to export learned clauses.
+// The 'learning' can check the size of the learn clause and only if it
+// returns true then the individual literals of the learned clause are given
+// to the learn through 'learn' one by one terminated by a zero literal.
+
+class Learner {
+public:
+  virtual ~Learner () { }
+  virtual bool learning (int size) = 0;
+  virtual void learn (int lit) = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
 /*------------------------------------------------------------------------*/
 
 // Allows to traverse all remaining irredundant clauses.  Satisfied and
-// eliminated clauses are not included, nor any derived units unless the
-// unit variable is frozen. Falsified literals are skipped.  If the solver
+// eliminated clauses are not included, nor any derived units unless such
+// a unit literal is frozen. Falsified literals are skipped.  If the solver
 // is inconsistent only the empty clause is traversed.
 //
-// If 'clause' returns false traversal can abort early.
-//
+// If 'clause' returns false traversal aborts early.
+
 class ClauseIterator {
 public:
   virtual ~ClauseIterator () { }
@@ -754,6 +865,8 @@ class ClauseIterator {
 // remaining clauses to satisfy the clauses on the extension stack too.
 //
 // All derived units of non-frozen variables are included too.
+//
+// If 'witness' returns false traversal aborts early.
 
 class WitnessIterator {
 public:
diff --git a/src/ccadical.cpp b/src/ccadical.cpp
index bde1f128..c20c9fd9 100644
--- a/src/ccadical.cpp
+++ b/src/ccadical.cpp
@@ -1,14 +1,62 @@
 #include "cadical.hpp"
 
+#include <cstdlib>
+#include <cstring>
+
 namespace CaDiCaL {
 
-struct Wrapper : Terminator {
+struct Wrapper : Learner, Terminator {
+
   Solver * solver;
-  void * state;
-  int (*function) (void *);
-  bool terminate () { return function ? function (state) : false; }
-  Wrapper () : solver (new Solver ()), state (0), function (0) { }
-  ~Wrapper () { function = 0; delete solver; }
+  struct {
+    void * state;
+    int (*function) (void *);
+  } terminator;
+
+  struct {
+    void * state;
+    int max_length;
+    int * begin_clause, * end_clause, * capacity_clause;
+    void (*function) (void *, int *);
+  } learner;
+
+  bool terminate () {
+    if (!terminator.function)
+      return false;
+    return terminator.function (terminator.state);
+  }
+
+  bool learning (int size) {
+    if (!learner.function)
+      return false;
+    return size <= learner.max_length;
+  }
+
+  void learn (int lit) {
+    if (learner.end_clause == learner.capacity_clause) {
+      size_t count = learner.end_clause - learner.begin_clause;
+      size_t size = count ? 2*count : 1;
+      learner.begin_clause = (int*)
+        realloc (learner.begin_clause, size * sizeof (int));
+      learner.end_clause = learner.begin_clause + count;
+      learner.capacity_clause = learner.begin_clause + size;
+    }
+    *learner.end_clause++ = lit;
+    if (lit)
+      return;
+    learner.function (learner.state, learner.begin_clause);
+    learner.end_clause = learner.begin_clause;
+  }
+
+  Wrapper () : solver (new Solver ()) {
+    memset (&terminator, 0, sizeof terminator);
+    memset (&learner, 0, sizeof learner);
+  }
+
+  ~Wrapper () {
+    terminator.function = 0;
+    if (learner.begin_clause) free (learner.begin_clause);
+    delete solver; }
 };
 
 }
@@ -92,12 +140,24 @@ int ccadical_fixed (CCaDiCaL * wrapper, int lit) {
 void ccadical_set_terminate (CCaDiCaL * ptr,
                              void * state, int (*terminate)(void *)) {
   Wrapper * wrapper = (Wrapper *) ptr;
-  wrapper->state = state;
-  wrapper->function = terminate;
+  wrapper->terminator.state = state;
+  wrapper->terminator.function = terminate;
   if (terminate) wrapper->solver->connect_terminator (wrapper);
   else wrapper->solver->disconnect_terminator ();
 }
 
+void ccadical_set_learn (CCaDiCaL * ptr,
+                         void * state, int max_length,
+			 void (*learn)(void * state, int * clause)) {
+  Wrapper * wrapper = (Wrapper *) ptr;
+  wrapper->learner.state = state;
+  wrapper->learner.max_length = max_length;
+  wrapper->learner.function = learn;
+  if (learn) wrapper->solver->connect_learner (wrapper);
+  else wrapper->solver->disconnect_learner ();
+}
+
+
 void ccadical_freeze (CCaDiCaL * ptr, int lit) {
   ((Wrapper*) ptr)->solver->freeze (lit);
 }
diff --git a/src/ccadical.h b/src/ccadical.h
index ed3da407..4173aedc 100644
--- a/src/ccadical.h
+++ b/src/ccadical.h
@@ -26,6 +26,9 @@ int ccadical_failed (CCaDiCaL *, int lit);
 void ccadical_set_terminate (CCaDiCaL *,
   void * state, int (*terminate)(void * state));
 
+void ccadical_set_learn (CCaDiCaL *,
+  void * state, int max_length, void (*learn)(void * state, int * clause));
+
 /*------------------------------------------------------------------------*/
 
 // Non-IPASIR conformant 'C' functions.
diff --git a/src/checker.cpp b/src/checker.cpp
index 2d1e14ac..cfaeb4f1 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -216,8 +216,9 @@ void Checker::enlarge_vars (int64_t idx) {
   new_vals = new signed char [ 2*new_size_vars ];
   clear_n (new_vals, 2*new_size_vars);
   new_vals += new_size_vars;
-  memcpy ((void*) (new_vals - size_vars),
-          (void*) (vals - size_vars), 2*size_vars);
+  if (size_vars) // To make sanitizer happy (without '-O').
+    memcpy ((void*) (new_vals - size_vars),
+            (void*) (vals - size_vars), 2*size_vars);
   vals -= size_vars;
   delete [] vals;
   vals = new_vals;
@@ -484,12 +485,12 @@ void Checker::add_derived_clause (const vector<int> & c) {
   if (tautological ())
     LOG ("CHECKER ignoring satisfied derived clause");
   else if (!check ()) {
-    internal->fatal_message_start ();
+    fatal_message_start ();
     fputs ("failed to check derived clause:\n", stderr);
     for (const auto & lit : unsimplified)
       fprintf (stderr, "%d ", lit);
     fputc ('0', stderr);
-    internal->fatal_message_end ();
+    fatal_message_end ();
   } else add_clause ("derived");
   simplified.clear ();
   unsimplified.clear ();
@@ -520,12 +521,12 @@ void Checker::delete_clause (const vector<int> & c) {
       if (num_garbage > 0.5 * max ((size_t) size_clauses, (size_t) size_vars))
         collect_garbage_clauses ();
     } else {
-      internal->fatal_message_start ();
+      fatal_message_start ();
       fputs ("deleted clause not in proof:\n", stderr);
       for (const auto & lit : unsimplified)
         fprintf (stderr, "%d ", lit);
       fputc ('0', stderr);
-      internal->fatal_message_end ();
+      fatal_message_end ();
     }
   }
   simplified.clear ();
@@ -533,4 +534,22 @@ void Checker::delete_clause (const vector<int> & c) {
   STOP (checking);
 }
 
+/*------------------------------------------------------------------------*/
+
+void Checker::dump () {
+  int max_var = 0;
+  for (uint64_t i = 0; i < size_clauses; i++)
+    for (CheckerClause * c = clauses[i]; c; c = c->next)
+      for (unsigned i = 0; i < c->size; i++)
+        if (abs (c->literals[i]) > max_var)
+          max_var = abs (c->literals[i]);
+  printf ("p cnf %d %" PRIu64 "\n", max_var, num_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++)
+    for (CheckerClause * c = clauses[i]; c; c = c->next) {
+      for (unsigned i = 0; i < c->size; i++)
+        printf ("%d ", c->literals[i]);
+      printf ("0\n");
+    }
+}
+
 }
diff --git a/src/checker.hpp b/src/checker.hpp
index 08d6de3f..90bfa7e9 100644
--- a/src/checker.hpp
+++ b/src/checker.hpp
@@ -125,22 +125,22 @@ class Checker : public Observer {
 
   struct {
 
-    int64_t added;                 // number of added clauses
-    int64_t original;              // number of added original clauses
-    int64_t derived;               // number of added derived clauses
+    int64_t added;              // number of added clauses
+    int64_t original;           // number of added original clauses
+    int64_t derived;            // number of added derived clauses
 
-    int64_t deleted;               // number of deleted clauses
+    int64_t deleted;            // number of deleted clauses
 
-    int64_t assumptions;           // number of assumed literals
-    int64_t propagations;          // number of propagated literals
+    int64_t assumptions;        // number of assumed literals
+    int64_t propagations;       // number of propagated literals
 
-    int64_t insertions;            // number of clauses added to hash table
-    int64_t collisions;            // number of hash collisions in 'find'
-    int64_t searches;              // number of searched clauses in 'find'
+    int64_t insertions;         // number of clauses added to hash table
+    int64_t collisions;         // number of hash collisions in 'find'
+    int64_t searches;           // number of searched clauses in 'find'
 
-    int64_t checks;                // number of implication checks
+    int64_t checks;             // number of implication checks
 
-    int64_t collections;           // garbage collections
+    int64_t collections;        // garbage collections
     int64_t units;
 
   } stats;
@@ -157,6 +157,7 @@ class Checker : public Observer {
   void delete_clause (const vector<int> &);
 
   void print_stats ();
+  void dump ();                 // for debugging purposes only
 };
 
 }
diff --git a/src/clause.cpp b/src/clause.cpp
index 24675e69..0669eb52 100644
--- a/src/clause.cpp
+++ b/src/clause.cpp
@@ -83,7 +83,7 @@ Clause * Internal::new_clause (bool red, int glue) {
   else if (glue <= opts.reducetier1glue) keep = true;
   else keep = false;
 
-  size_t bytes = sizeof (Clause) + (size - 2) * sizeof (int);
+  size_t bytes = Clause::bytes (size);
   Clause * c = (Clause *) new char[bytes];
 
   stats.added.total++;
@@ -133,7 +133,7 @@ Clause * Internal::new_clause (bool red, int glue) {
   }
 
   clauses.push_back (c);
-  LOG (c, "new");
+  LOG (c, "new pointer %p", c);
 
   if (likely_to_be_kept_clause (c)) mark_added (c);
 
@@ -211,12 +211,12 @@ size_t Internal::shrink_clause (Clause * c, int new_size) {
 void Internal::deallocate_clause (Clause * c) {
   char * p = (char*) c;
   if (arena.contains (p)) return;
-  LOG (c, "deallocate");
+  LOG (c, "deallocate pointer %p", c);
   delete [] p;
 }
 
 void Internal::delete_clause (Clause * c) {
-  LOG (c, "delete");
+  LOG (c, "delete pointer %p", c);
   size_t bytes = c->bytes ();
   stats.collected += bytes;
   if (c->garbage) {
@@ -254,6 +254,7 @@ void Internal::delete_clause (Clause * c) {
 // 'check_clause_stats' after garbage collection in debugging mode.
 //
 void Internal::mark_garbage (Clause * c) {
+
   assert (!c->garbage);
 
   // Delay tracing deletion of binary clauses.  See the discussion above in
@@ -279,6 +280,8 @@ void Internal::mark_garbage (Clause * c) {
   stats.garbage += bytes;
   c->garbage = true;
   c->used = 0;
+
+  LOG (c, "marked garbage pointer %p", c);
 }
 
 /*------------------------------------------------------------------------*/
@@ -303,6 +306,9 @@ void Internal::assign_original_unit (int lit) {
   trail.push_back (lit);
   LOG ("original unit assign %d", lit);
   mark_fixed (lit);
+  if (propagate ()) return;
+  LOG ("propagation of original unit results in conflict");
+  learn_empty_clause ();
 }
 
 // New clause added through the API, e.g., while parsing a DIMACS file.
@@ -346,7 +352,7 @@ void Internal::add_new_original_clause () {
     size_t size = clause.size ();
     if (!size) {
       if (!unsat) {
-        if (!original.size ()) MSG ("found empty original clause");
+        if (!original.size ()) VERBOSE (1, "found empty original clause");
         else MSG ("found falsified original clause");
         unsat = true;
       }
diff --git a/src/clause.hpp b/src/clause.hpp
index 740b71fa..f92e57bb 100644
--- a/src/clause.hpp
+++ b/src/clause.hpp
@@ -81,18 +81,18 @@ struct Clause {
   //
   int glue;
 
-  int size;         // actual size of 'literals' (at least 2)
-  int pos;          // position of last watch replacement
+  int size;         // Actual size of 'literals' (at least 2).
+  int pos;          // Position of last watch replacement [Gent'13].
 
   union {
 
-    int literals[2];    // of variadic 'size' (not just 2) in general
+    int literals[2];    // Of variadic 'size' (shrunken if strengthened).
 
-    Clause * copy;      // only valid if 'moved', then that's where to
+    Clause * copy;      // Only valid if 'moved', then that's where to.
     //
     // The 'copy' field is only valid for 'moved' clauses in the moving
     // garbage collector 'copy_non_garbage_clauses' for keeping clauses
-    // compactly in a contiguous memory arena.  Otherwise, that is most of
+    // compactly in a contiguous memory arena.  Otherwise, most of
     // the time, 'literals' is valid.  See 'collect.cpp' for details.
   };
 
@@ -102,7 +102,19 @@ struct Clause {
   const_literal_iterator begin () const { return literals; }
   const_literal_iterator   end () const { return literals + size; }
 
-  size_t bytes () const { return (size - 2) * sizeof (int) + sizeof *this; }
+  static size_t bytes (int size) {
+
+    // Memory sanitizer insists that clauses put into consecutive memory in
+    // the arena are still 8 byte aligned.  We could also allocate 8 byte
+    // aligned memory there.  However, assuming the real memory foot print
+    // of a clause is 8 bytes anyhow, we just allocate 8 byte aligned memory
+    // all the time (even if allocated outside of the arena).
+    //
+    assert (size > 1);
+    return align ((size - 2) * sizeof (int) + sizeof (Clause), 8);
+  }
+
+  size_t bytes () const { return bytes (size); }
 
   // Check whether this clause is ready to be collected and deleted.  The
   // 'reason' flag is only there to protect reason clauses in 'reduce',
diff --git a/src/collect.cpp b/src/collect.cpp
index 72475343..9674e621 100644
--- a/src/collect.cpp
+++ b/src/collect.cpp
@@ -75,6 +75,62 @@ void Internal::mark_satisfied_clauses_as_garbage () {
 
 /*------------------------------------------------------------------------*/
 
+// Reason clauses can not be collected.
+//
+// We protect reasons before and release protection after garbage collection
+// (actually within garbage collection).
+//
+// For 'reduce' we still need to make sure that all clauses which should not
+// be removed are marked as such and thus we need to call it before marking
+// clauses to be flushed.
+
+void Internal::protect_reasons () {
+  LOG ("protecting reason clauses of all assigned variables on trail");
+  assert (!protected_reasons);
+  size_t count = 0;
+  for (const auto & lit : trail) {
+    if (!active (lit)) continue;
+    assert (val (lit));
+    Var & v = var (lit);
+    assert (v.level > 0);
+    Clause * reason = v.reason;
+    if (!reason) continue;
+    LOG (reason, "protecting assigned %d reason %p", lit, reason);
+    assert (!reason->reason);
+    reason->reason = true;
+    count++;
+  }
+  LOG ("protected %zd reason clauses referenced on trail", count);
+  protected_reasons = true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// After garbage collection we reset the 'reason' flag of the reasons
+// of assigned literals on the trail.
+
+void Internal::unprotect_reasons () {
+  LOG ("unprotecting reasons clauses of all assigned variables on trail");
+  assert (protected_reasons);
+  size_t count = 0;
+  for (const auto & lit : trail) {
+    if (!active (lit)) continue;
+    assert (val (lit));
+    Var & v = var (lit);
+    assert (v.level > 0);
+    Clause * reason = v.reason;
+    if (!reason) continue;
+    LOG (reason, "unprotecting assigned %d reason %p", lit, reason);
+    assert (reason->reason);
+    reason->reason = false;
+    count++;
+  }
+  LOG ("unprotected %zd reason clauses referenced on trail", count);
+  protected_reasons = false;
+}
+
+/*------------------------------------------------------------------------*/
+
 // Update occurrence lists before deleting garbage clauses in the context of
 // preprocessing, e.g., during bounded variable elimination 'elim'.  The
 // result is the number of remaining clauses, which in this context means
@@ -131,18 +187,38 @@ inline void Internal::flush_watches (int lit, Watches & saved) {
 
 void Internal::flush_all_occs_and_watches () {
   if (occurring ())
-    for (int idx = 1; idx <= max_var; idx++)
+    for (auto idx : vars)
       flush_occs (idx), flush_occs (-idx);
 
   if (watching ()) {
     Watches tmp;
-    for (int idx = 1; idx <= max_var; idx++)
+    for (auto idx : vars)
       flush_watches (idx, tmp), flush_watches (-idx, tmp);
   }
 }
 
 /*------------------------------------------------------------------------*/
 
+void Internal::update_reason_references () {
+  LOG ("update assigned reason references");
+  size_t count = 0;
+  for (auto & lit : trail) {
+    if (!active (lit)) continue;
+    Var & v = var (lit);
+    Clause * c = v.reason;
+    if (!c) continue;
+    LOG (c, "updating assigned %d reason", lit);
+    assert (c->reason);
+    assert (c->moved);
+    Clause * d = c->copy;
+    v.reason = d;
+    count++;
+  }
+  LOG ("updated %zd assigned reason references", count);
+}
+
+/*------------------------------------------------------------------------*/
+
 // This is a simple garbage collector which does not move clauses.  It needs
 // less space than the arena based clause allocator, but is not as cache
 // efficient, since the copying garbage collector can put clauses together
@@ -182,20 +258,11 @@ void Internal::delete_garbage_clauses () {
 void Internal::copy_clause (Clause * c) {
   LOG (c, "moving");
   assert (!c->moved);
-  char * p = (char*) c, * q = arena.copy (p, c->bytes ());
-  Clause * d = c->copy = (Clause *) q;
-  LOG ("copied clause[%p] to clause[%p]", c, d);
-  if (d->reason) {
-    assert (level > 0);
-    Var & v = var (d->literals[0]);
-    if (v.reason == c) v.reason = d;
-    else {
-      Var & u = var (d->literals[1]);
-      assert (u.reason == c);
-      u.reason = d;
-    }
-  }
+  char * p = (char*) c;
+  char * q = arena.copy (p, c->bytes ());
+  c->copy = (Clause *) q;
   c->moved = true;
+  LOG ("copied clause[%" PRId64 "] from %p to %p", c->id, c, c->copy);
 }
 
 // This is the moving garbage collector.
@@ -255,7 +322,7 @@ void Internal::copy_non_garbage_clauses () {
     // Our version uses saved phases too.
 
     for (int sign = -1; sign <= 1; sign += 2)
-      for (int idx = 1; idx <= max_var; idx++)
+      for (auto idx : vars)
         for (const auto & w : watches (sign * likely_phase (idx)))
           if (!w.clause->moved && !w.clause->collect ())
             copy_clause (w.clause);
@@ -284,9 +351,8 @@ void Internal::copy_non_garbage_clauses () {
     if (!c->collect () && !c->moved)
       copy_clause (c);
 
-  // Update watches or occurrence lists.
-  //
   flush_all_occs_and_watches ();
+  update_reason_references ();
 
   // Replace and flush clause references in 'clauses'.
   //
@@ -349,10 +415,12 @@ void Internal::garbage_collection () {
   report ('G', 1);
   stats.collections++;
   mark_satisfied_clauses_as_garbage ();
+  if (!protected_reasons) protect_reasons ();
   if (arenaing ()) copy_non_garbage_clauses ();
   else delete_garbage_clauses ();
   check_clause_stats ();
   check_var_stats ();
+  unprotect_reasons ();
   report ('C', 1);
   STOP (collect);
 }
diff --git a/src/compact.cpp b/src/compact.cpp
index 38f809d8..5598b239 100644
--- a/src/compact.cpp
+++ b/src/compact.cpp
@@ -12,7 +12,6 @@ namespace CaDiCaL {
 
 bool Internal::compacting () {
   if (level) return false;
-  if (!opts.simplify) return false;
   if (!opts.compact) return false;
   if (stats.conflicts < lim.compact) return false;
   int inactive = max_var - active ();
@@ -49,12 +48,12 @@ struct Mapper {
     map_first_fixed (0),
     first_fixed_val (0)
   {
-    table = new int [ internal->max_var + 1 ];
-    clear_n (table, internal->max_var + 1);
+    table = new int [ internal->max_var + 1u ];
+    clear_n (table, internal->max_var + 1u);
 
     assert (!internal->level);
 
-    for (int src = 1; src <= internal->max_var; src++) {
+    for (auto src : internal->vars) {
       const Flags & f = internal->flags (src);
       if (f.active ()) table[src] = ++new_max_var;
       else if (f.fixed () && !first_fixed)
@@ -62,7 +61,7 @@ struct Mapper {
     }
 
     first_fixed_val = first_fixed ? internal->val (first_fixed) : 0;
-    new_vsize = new_max_var + 1;
+    new_vsize = new_max_var + 1u;
   }
 
   ~Mapper () { delete [] table; }
@@ -71,7 +70,8 @@ struct Mapper {
   // Map old variable indices.  A result of zero means not mapped.
   //
   int map_idx (int src) {
-    assert (0 < src), assert (src <= internal->max_var);
+    assert (0 < src);
+    assert (src <= internal->max_var);
     const int res = table[src];
     assert (res <= new_max_var);
     return res;
@@ -101,8 +101,7 @@ struct Mapper {
   //
   template<class T>
   void map_vector (vector<T> & v) {
-    const int max_var = internal->max_var;
-    for (int src = 1; src <= max_var; src++) {
+    for (auto src : internal->vars) {
       const int dst = map_idx (src);
       if (!dst) continue;
       assert (0 < dst);
@@ -118,8 +117,7 @@ struct Mapper {
   //
   template<class T>
   void map2_vector (vector<T> & v) {
-    const int max_var = internal->max_var;
-    for (int src = 1; src <= max_var; src++) {
+    for (auto src : internal->vars) {
       const int dst = map_idx (src);
       if (!dst) continue;
       assert (0 < dst);
@@ -195,10 +193,10 @@ void Internal::compact () {
 
   // Flush the external indices.  This has to occur before we map 'vals'.
   //
-  for (int eidx = 1; eidx <= external->max_var; eidx++) {
-    int src = external->e2i[eidx], dst;
+  for (auto eidx : external->vars) {
+    int src = external->e2i[eidx];
     if (!src) continue;
-    dst = mapper.map_lit (src);
+    int dst = mapper.map_lit (src);
     LOG ("compact %" PRId64 " maps external %d to internal %d from internal %d",
       stats.compacts, eidx, dst, src);
     external->e2i[eidx] = dst;
@@ -220,10 +218,9 @@ void Internal::compact () {
   // Map the blocking literals in all watches.
   //
   if (!wtab.empty ())
-    for (int idx = 1; idx <= max_var; idx++)
-      for (int sign = -1; sign <= 1; sign += 2)
-        for (auto & w : watches (sign*idx))
-          w.blit = mapper.map_lit (w.blit);
+    for (auto lit : lits)
+      for (auto & w : watches (lit))
+        w.blit = mapper.map_lit (w.blit);
 
   // We first flush inactive variables and map the links in the queue.  This
   // has to be done before we map the actual links data structure 'links'.
@@ -266,8 +263,10 @@ void Internal::compact () {
   // 'Internal::enlarge' which reallocates in order of allocated bytes.
 
   mapper.map_vector (ftab);
+  mapper.map_vector (parents);
   mapper.map_vector (marks);
   mapper.map_vector (phases.saved);
+  mapper.map_vector (phases.forced);
   mapper.map_vector (phases.target);
   mapper.map_vector (phases.best);
   mapper.map_vector (phases.prev);
@@ -275,7 +274,7 @@ void Internal::compact () {
 
   // Special code for 'frozentab'.
   //
-  for (int src = 1; src <= max_var; src++) {
+  for (auto src : vars) {
     const int dst = mapper.map_idx (src);
     if (!dst) continue;
     if (src == dst) continue;
@@ -312,9 +311,9 @@ void Internal::compact () {
     signed char * new_vals = new signed char [ 2*mapper.new_vsize ];
     ignore_clang_analyze_memory_leak_warning = new_vals;
     new_vals += mapper.new_vsize;
-    for (int src = -max_var; src <= -1; src++)
-      new_vals[-mapper.map_idx (-src)] = vals[src];
-    for (int src = 1; src <= max_var; src++)
+    for (auto src : vars)
+      new_vals[-mapper.map_idx (src)] = vals[-src];
+    for (auto src : vars)
       new_vals[mapper.map_idx (src)] = vals[src];
     new_vals[0] = 0;
     vals -= vsize;
@@ -329,7 +328,6 @@ void Internal::compact () {
   mapper.map_vector (links);
   mapper.map_vector (vtab);
   if (!ntab.empty ()) mapper.map2_vector (ntab);
-  if (!ntab2.empty ()) mapper.map_vector (ntab2);
   if (!wtab.empty ()) mapper.map2_vector (wtab);
   if (!otab.empty ()) mapper.map2_vector (otab);
   if (!big.empty ()) mapper.map2_vector (big);
@@ -376,7 +374,7 @@ void Internal::compact () {
 
   size_t new_target_assigned = 0, new_best_assigned = 0;
 
-  for (int idx = 1; idx <= mapper.new_max_var; idx++) {
+  for (auto idx : Range (mapper.new_max_var)) {
     if (phases.target[idx]) new_target_assigned++;
     if (phases.best[idx]) new_best_assigned++;
   }
diff --git a/src/condition.cpp b/src/condition.cpp
index 904010cb..61a65203 100644
--- a/src/condition.cpp
+++ b/src/condition.cpp
@@ -34,7 +34,6 @@ namespace CaDiCaL {
 
 bool Internal::conditioning () {
 
-  if (!opts.simplify) return false;
   if (!opts.condition) return false;
   if (!preprocessing && !opts.inprocessing) return false;
   if (preprocessing) assert (lim.preprocessing);
@@ -51,7 +50,7 @@ bool Internal::conditioning () {
   double remain = active ();
   if (!remain) return false;
   double ratio = stats.current.irredundant / remain;
-  return ratio <= opts.conditionmaxratio;
+  return ratio <= opts.conditionmaxrat;
 }
 
 /*------------------------------------------------------------------------*/
@@ -114,7 +113,7 @@ inline void Internal::unmark_as_conditional_literal (int lit) {
 
 /*------------------------------------------------------------------------*/
 
-// We also need to now the literals which are in the current clause.  These
+// We also need to know the literals which are in the current clause.  These
 // are just marked (also in 'marks' but with the (signed) upper two bits).
 // We need a signed mark here, since we have to distinguish positive and
 // negative occurrences of literals in the candidate clause.
@@ -159,11 +158,13 @@ long Internal::condition_round (long delta) {
 
   LOG ("initial trail level %zd", initial_trail_level);
 
+  protect_reasons ();
+
 #if defined(LOGGING) || !defined(NDEBUG)
   int additionally_assigned = 0;
 #endif
 
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     const signed char tmp = val (idx);
     Var & v = var (idx);
     if (tmp) {
@@ -218,7 +219,7 @@ long Internal::condition_round (long delta) {
   struct { size_t assigned, conditional, autarky; } initial, remain;
 
   initial.assigned = 0;
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     const signed char tmp = val (idx);
     if (!tmp) continue;
     if (!var (idx).level) continue;
@@ -417,7 +418,7 @@ long Internal::condition_round (long delta) {
   // Make sure to focus on clauses not tried before by marking clauses which
   // have been checked before using the 'conditioned' bit of clauses. If all
   // candidates have their bit set, we have to reset it.  Since the
-  // assignment might be completely different than last time and thus also
+  // assignment might be completely different then last time and thus also
   // the set of candidates this method does not really exactly lead to a
   // round robin scheme of scheduling clauses.
   //
@@ -457,8 +458,16 @@ long Internal::condition_round (long delta) {
 
     if (initial.autarky <= 0) break;
 
-    if (terminating () || stats.condprops >= limit) {
+    if (c->reason) continue;
+
+    bool terminated_or_limit_hit = true;
+    if (terminated_asynchronously ())
+      LOG ("asynchronous termination detected");
+    else if (stats.condprops >= limit)
       LOG ("condition propagation limit %ld hit", limit);
+    else terminated_or_limit_hit = false;
+
+    if (terminated_or_limit_hit) {
       PHASE ("condition", stats.conditionings,
         "%zd candidates %.0f%% not tried after %ld propagations",
         untried, percent (untried, candidates.size ()), props);
@@ -481,8 +490,8 @@ long Internal::condition_round (long delta) {
     int watched_autarky_literal = 0;
 
     // First mark all true literals in the candidate clause and find an
-    // autarky literal which witnesses that this clause can in principle be
-    // globally
+    // autarky literal which witnesses that this clause has still a chance
+    // to be globally blocked.
     //
     for (const_literal_iterator l = c->begin (); l != c->end (); l++)
     {
@@ -824,6 +833,8 @@ long Internal::condition_round (long delta) {
     level = initial_level;
   }
 
+  reset_occs ();
+
   // Reassign previously assigned variables again.
   //
   LOG ("reassigning previously assigned variables");
@@ -839,7 +850,7 @@ long Internal::condition_round (long delta) {
     assert (!marked (lit));
 #endif
 
-  reset_occs ();
+  unprotect_reasons ();
 
   return blocked;
 }
diff --git a/src/config.cpp b/src/config.cpp
index 29a1cb4d..1ca54408 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -6,6 +6,17 @@ namespace CaDiCaL {
 
 struct NameVal { const char * name; int val; };
 
+/*------------------------------------------------------------------------*/
+
+// These are dummy configurations, which require additional code.
+
+static NameVal default_config[1];       // With '-pedantic' just '[]' or
+static NameVal plain_config[1];         // '[0]' gave a warning.
+
+/*------------------------------------------------------------------------*/
+
+// Here we have the pre-defined default configurations.
+
 static NameVal sat_config[] = {
   { "elimreleff", 10 },
   { "stabilizeonly", 1 },
@@ -21,13 +32,22 @@ static NameVal unsat_config[] = {
 
 #define CONFIGS \
  \
-CONFIG(sat,"target satisfiable instances") \
-CONFIG(unsat,"target unsatisfiable instances") \
+CONFIG(default,"set default advanced internal options") \
+CONFIG(plain,"disable all internal preprocessing options") \
+CONFIG(sat,"set internal options to target satisfiable instances") \
+CONFIG(unsat,"set internal options to target unsatisfiable instances") \
+
+static const char * configs [] = {
+#define CONFIG(N,D) #N,
+CONFIGS
+#undef CONFIG
+};
+
+static size_t num_configs = sizeof configs / sizeof *configs;
 
 /*------------------------------------------------------------------------*/
 
 bool Config::has (const char * name) {
-  if (!strcmp (name, "default")) return true;
 #define CONFIG(N,D) \
   if (!strcmp (name, #N)) return true;
   CONFIGS
@@ -35,16 +55,23 @@ bool Config::has (const char * name) {
   return false;
 }
 
-bool Config::set (Solver & solver, const char * name) {
-  if (!strcmp (name, "default")) return true;
+bool Config::set (Options & opts, const char * name) {
+  if (!strcmp (name, "default")) {
+    opts.reset_default_values ();
+    return true;
+  }
+  if (!strcmp (name, "plain")) {
+    opts.disable_preprocessing ();
+    return true;
+  }
 #define CONFIG(N,D) \
   do { \
     if (strcmp (name, #N)) break; \
     const NameVal * BEGIN = N ## _config; \
     const NameVal * END = BEGIN + sizeof N ##_config / sizeof (NameVal); \
     for (const NameVal * P = BEGIN; P != END; P++) { \
-      assert (solver.is_valid_option (P->name)); \
-      solver.set (P->name, P->val); \
+      assert (Options::has (P->name)); \
+      opts.set (P->name, P->val); \
     } \
     return true; \
   } while (0);
@@ -53,21 +80,18 @@ bool Config::set (Solver & solver, const char * name) {
   return false;
 }
 
-const char * Config::description (const char * name) {
-  if (!strcmp (name, "default"))
-    return "should work in most situations";
-#define CONFIG(N,D) \
-  if (!strcmp (name, #N)) return D;
-  CONFIGS
-#undef CONFIG
-  return 0;
-}
+/*------------------------------------------------------------------------*/
 
 void Config::usage () {
 #define CONFIG(N,D) \
-  printf ("  %-26s " D "\n", "--" #N);
+  printf ("  %-14s " D "\n", "--" #N);
   CONFIGS
 #undef CONFIG
 }
 
+/*------------------------------------------------------------------------*/
+
+const char ** Config::begin () { return configs; }
+const char ** Config::end () { return &configs[num_configs]; }
+
 }
diff --git a/src/config.hpp b/src/config.hpp
index 9bdc49de..c66a10f9 100644
--- a/src/config.hpp
+++ b/src/config.hpp
@@ -5,12 +5,15 @@ namespace CaDiCaL {
 
 class Options;
 
-namespace Config {
-  bool has (const char *);
-  const char * description (const char *);
-  bool set (Solver &, const char *);
-  void usage ();
-}
+struct Config {
+
+  static bool has (const char *);
+  static bool set (Options &, const char *);
+  static void usage ();
+
+  static const char ** begin ();
+  static const char ** end ();
+};
 
 }
 
diff --git a/src/contract.cpp b/src/contract.cpp
new file mode 100644
index 00000000..015abfa6
--- /dev/null
+++ b/src/contract.cpp
@@ -0,0 +1,27 @@
+#ifndef NCONTRACTS
+
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void fatal_message_start ();
+
+// See comments in 'contract.hpp'. Ugly hack we keep for now.
+
+void require_solver_pointer_to_be_non_zero (const void * ptr,
+                                            const char * function_name,
+                                            const char * file_name)
+{
+  if (ptr) return;
+  fatal_message_start ();
+  fprintf (stderr,
+    "invalid API usage of '%s' in '%s': "
+    "solver 'this' pointer zero (not initialized)\n",
+    function_name, file_name);
+  fflush (stderr);
+  abort ();
+}
+
+}
+
+#endif
diff --git a/src/contract.hpp b/src/contract.hpp
index 78c6d632..ec5a6ba0 100644
--- a/src/contract.hpp
+++ b/src/contract.hpp
@@ -1,6 +1,8 @@
 #ifndef _contract_hpp_INCLUDED
 #define _contract_hpp_INCLUDED
 
+/*------------------------------------------------------------------------*/
+#ifndef NCONTRACTS
 /*------------------------------------------------------------------------*/
 
 // If the user violates API contracts while calling functions declared in
@@ -11,7 +13,7 @@
 
 #define CONTRACT_VIOLATED(...) \
 do { \
-  Internal::fatal_message_start (); \
+  fatal_message_start (); \
   fprintf (stderr, \
     "invalid API usage of '%s' in '%s': ", \
     __PRETTY_FUNCTION__, __FILE__); \
@@ -23,6 +25,34 @@ do { \
 
 /*------------------------------------------------------------------------*/
 
+namespace CaDiCaL {
+
+// It would be much easier to just write 'REQUIRE (this, "not initialized")'
+// which however produces warnings due to the '-Wnonnull' check. Note, that
+// 'this' is always assumed to be non zero in modern C++.  Much worse, if we
+// use instead 'this != 0' or something similar like 'this != nullptr' then
+// optimization silently removes this check ('gcc-7.4.0' at least) even
+// though of course a zero pointer might be used as 'this' if the user did
+// not initialize it.  The only solution I found is to disable optimization
+// for this check. It does not seem to be necessary for 'clang++' though
+// ('clang++-6.0.0' at least).  The alternative is to not check that the
+// user forgot to initialize the solver pointer, but as long this works we
+// keep this ugly hack. It also forces the function not to be inlined.
+// The actual code I is in 'contract.cpp'.
+//
+void require_solver_pointer_to_be_non_zero (const void *ptr,
+                                            const char * function_name,
+                                            const char * file_name);
+#define REQUIRE_NON_ZERO_THIS() \
+do { \
+  require_solver_pointer_to_be_non_zero (this, \
+    __PRETTY_FUNCTION__, __FILE__); \
+} while (0)
+
+}
+
+/*------------------------------------------------------------------------*/
+
 // These are common shortcuts for 'Solver' API contracts (requirements).
 
 #define REQUIRE(COND,...) \
@@ -33,9 +63,9 @@ do { \
 
 #define REQUIRE_INITIALIZED() \
 do { \
-  REQUIRE(this != 0, "solver not initialized"); \
-  REQUIRE(external != 0, "internal solver not initialized"); \
-  REQUIRE(internal != 0, "internal solver not initialized"); \
+  REQUIRE_NON_ZERO_THIS (); \
+  REQUIRE(external, "external solver not initialized"); \
+  REQUIRE(internal, "internal solver not initialized"); \
 } while (0)
 
 #define REQUIRE_VALID_STATE() \
@@ -44,6 +74,13 @@ do { \
   REQUIRE(this->state () & VALID, "solver in invalid state"); \
 } while (0)
 
+#define REQUIRE_READY_STATE() \
+do { \
+  REQUIRE_VALID_STATE (); \
+  REQUIRE (state () != ADDING, \
+    "clause incomplete (terminating zero not added)"); \
+} while (0)
+
 #define REQUIRE_VALID_OR_SOLVING_STATE() \
 do { \
   REQUIRE_INITIALIZED (); \
@@ -57,6 +94,19 @@ do { \
     "invalid literal '%d'", (int)(LIT)); \
 } while (0)
 
+/*------------------------------------------------------------------------*/
+#else // NCONTRACTS
+/*------------------------------------------------------------------------*/
+
+#define REQUIRE(...) do { } while (0)
+#define REQUIRE_INITIALIZED() do { } while (0)
+#define REQUIRE_VALID_STATE() do { } while (0)
+#define REQUIRE_READY_STATE() do { } while (0)
+#define REQUIRE_VALID_OR_SOLVING_STATE() do { } while (0)
+#define REQUIRE_VALID_LIT(...) do { } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif
 /*------------------------------------------------------------------------*/
 
 #endif
diff --git a/src/cover.cpp b/src/cover.cpp
index 74c50e3a..bd4530bc 100644
--- a/src/cover.cpp
+++ b/src/cover.cpp
@@ -355,7 +355,7 @@ bool Internal::cover_clause (Clause * c, Coveror & coveror) {
       stats.cover.total++;
       LOG (c, "asymmetric tautological");
       mark_garbage (c);
-    } else if (tautological) {
+    } else {
       stats.cover.blocked++;
       stats.cover.total++;
       LOG (c, "covered tautological");
@@ -490,20 +490,17 @@ int64_t Internal::cover_round () {
   // first, since then the chances are higher that the intersection of
   // resolution candidates becomes emptier earlier.
 
-  for (int idx = 1; idx <= max_var; idx++) {
-    if (!active (idx)) continue;
-    for (int sign = -1; sign <= 1; sign += 2) {
-      const int lit = sign * idx;
-      Occs & os = occs (lit);
-      stable_sort (os.begin (), os.end (), clause_smaller_size ());
-    }
+  for (auto lit : lits) {
+    if (!active (lit)) continue;
+    Occs & os = occs (lit);
+    stable_sort (os.begin (), os.end (), clause_smaller_size ());
   }
 
   // This is the main loop of trying to do CCE of candidate clauses.
   //
   int64_t covered = 0;
   //
-  while (!terminating () &&
+  while (!terminated_asynchronously () &&
          !schedule.empty () &&
          stats.propagations.cover < limit) {
     Clause * c = schedule.back ();
@@ -537,7 +534,9 @@ int64_t Internal::cover_round () {
 bool Internal::cover () {
 
   if (!opts.cover) return false;
-  if (unsat || terminating () || !stats.current.irredundant) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
+  if (!stats.current.irredundant) return false;
 
   // TODO: Our current algorithm for producing the necessary clauses on the
   // reconstruction stack for extending the witness requires a covered
diff --git a/src/decide.cpp b/src/decide.cpp
index 4d6c202c..cddb90e9 100644
--- a/src/decide.cpp
+++ b/src/decide.cpp
@@ -43,15 +43,18 @@ int Internal::next_decision_variable () {
 /*------------------------------------------------------------------------*/
 
 // Implements phase saving as well using a target phase during
-// stabilization unless decision phase is forced to the initial value.
+// stabilization unless decision phase is forced to the initial value
+// of a phase is forced through the 'phase' option.
 
 int Internal::decide_phase (int idx, bool target) {
   const int initial_phase = opts.phase ? 1 : -1;
   int phase = 0;
   if (force_saved_phase) phase = phases.saved[idx];
   if (!phase && opts.forcephase) phase = initial_phase;
-  if (!phase && target)  phase = phases.target[idx];
+  if (!phase) phase = phases.forced[idx];               // TODO swap?
+  if (!phase && target) phase = phases.target[idx];
   if (!phase) phase = phases.saved[idx];
+  COVER (!phase);
   if (!phase) phase = initial_phase;
   return phase * idx;
 }
diff --git a/src/decompose.cpp b/src/decompose.cpp
index 84c23c08..c520ca0e 100644
--- a/src/decompose.cpp
+++ b/src/decompose.cpp
@@ -24,18 +24,19 @@ struct DFS {
 bool Internal::decompose_round () {
 
   if (!opts.decompose) return false;
-  if (unsat || terminating ()) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
 
-  assert (opts.simplify);
   assert (!level);
 
   START_SIMPLIFIER (decompose, DECOMP);
 
   stats.decompositions++;
 
-  DFS * dfs = new DFS[2*(max_var + 1)];
-  int * reprs = new int[2*(max_var + 1)];
-  clear_n (reprs, 2*(max_var + 1));
+  const size_t size_dfs = 2*(1 + (size_t) max_var);
+  DFS * dfs = new DFS[size_dfs];
+  int * reprs = new int[size_dfs];
+  clear_n (reprs, size_dfs);
 
   int non_trivial_sccs = 0, substituted = 0;
 #ifndef QUIET
@@ -49,7 +50,8 @@ bool Internal::decompose_round () {
   // The binary implication graph might have disconnected components and
   // thus we have in general to start several depth first searches.
 
-  for (int root_idx = 1; !unsat && root_idx <= max_var; root_idx++) {
+  for (auto root_idx : vars) {
+    if (unsat) break;
     if (!active (root_idx)) continue;
     for (int root_sign = -1; !unsat && root_sign <= 1; root_sign += 2) {
       int root = root_sign * root_idx;
@@ -325,7 +327,8 @@ bool Internal::decompose_round () {
   // also just simply use the 'e2i' map as a union find data structure.
   // This would avoid the need to restore these clauses.
 
-  for (int idx = 1; !unsat && idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (unsat) break;
     if (!active (idx)) continue;
     int other = reprs [ vlit (idx) ];
     if (other == idx) continue;
diff --git a/src/deduplicate.cpp b/src/deduplicate.cpp
index 4d04ea89..f7e018d7 100644
--- a/src/deduplicate.cpp
+++ b/src/deduplicate.cpp
@@ -20,7 +20,8 @@ namespace CaDiCaL {
 void Internal::mark_duplicated_binary_clauses_as_garbage () {
 
   if (!opts.deduplicate) return;
-  if (unsat || terminating ()) return;
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
 
   START_SIMPLIFIER (deduplicate, DEDUP);
   stats.deduplications++;
@@ -33,8 +34,9 @@ void Internal::mark_duplicated_binary_clauses_as_garbage () {
   int64_t subsumed = 0;
   int64_t units = 0;
 
-  for (int idx = 1; !unsat && idx <= max_var; idx++) {
+  for (auto idx : vars) {
 
+    if (unsat) break;
     if (!active (idx)) continue;
     int unit = 0;
 
diff --git a/src/elim.cpp b/src/elim.cpp
index d8a55df9..6ff5b8e3 100644
--- a/src/elim.cpp
+++ b/src/elim.cpp
@@ -7,13 +7,13 @@ namespace CaDiCaL {
 // Implements a variant of bounded variable elimination as originally
 // described in our SAT'05 paper introducing 'SATeLite'.  This is an
 // inprocessing version, i.e., it is interleaved with search and triggers
-// blocked clause elimination, subsumption and strengthening rounds during
-// elimination rounds.  It focuses only those variables which occurred in
-// removed irredundant clauses since the last time an elimination round
-// was run.  By bounding the maximum resolvent size we can run each
-// elimination round until completion.  See the code of 'elim' for how
-// elimination rounds are interleaved with blocked clause elimination and
-// subsumption (which in turn also calls vivification and transitive
+// subsumption and strengthening, blocked and covered clause elimination
+// during elimination rounds.  It focuses only those variables which
+// occurred in removed irredundant clauses since the last time an
+// elimination round was run.  By bounding the maximum resolvent size we can
+// run each elimination round until completion.  See the code of 'elim' for
+// how elimination rounds are interleaved with blocked clause elimination
+// and subsumption (which in turn also calls vivification and transitive
 // reduction of the binary implication graph).
 
 /*------------------------------------------------------------------------*/
@@ -25,8 +25,9 @@ inline double Internal::compute_elim_score (unsigned lit) {
   const double neg = internal->ntab [uidx + 1];
   if (!pos) return -neg;
   if (!neg) return -pos;
-  double sum = pos + neg, prod = 0;
-  if (opts.elimprod) prod = opts.elimprod * pos * neg;
+  double sum = 0, prod = 0;
+  if (opts.elimsum) sum = opts.elimsum * (pos + neg);
+  if (opts.elimprod) prod = opts.elimprod * (pos * neg);
   return prod + sum;
 }
 
@@ -53,7 +54,6 @@ inline bool elim_more::operator () (unsigned a, unsigned b) {
 
 bool Internal::eliminating () {
 
-  if (!opts.simplify) return false;
   if (!opts.elim) return false;
   if (!preprocessing && !opts.inprocessing) return false;
   if (preprocessing) assert (lim.preprocessing);
@@ -374,7 +374,8 @@ Internal::elim_resolvents_are_bounded (Eliminator & eliminator, int pivot)
   if (!pos || !neg) return lim.elimbound >= 0;
   const int64_t bound = pos + neg + lim.elimbound;
 
-  LOG ("checking number resolvents on %d bounded by %" PRId64 " = %" PRId64 " + %" PRId64 " + %d",
+  LOG ("checking number resolvents on %d bounded by "
+    "%" PRId64 " = %" PRId64 " + %" PRId64 " + %d",
     pivot, bound, pos, neg, lim.elimbound);
 
   // Try all resolutions between a positive occurrence (outer loop) of
@@ -396,10 +397,12 @@ Internal::elim_resolvents_are_bounded (Eliminator & eliminator, int pivot)
         resolvents++;
         int size = clause.size ();
         clause.clear ();
-        LOG ("now at least %" PRId64 " non-tautological resolvents on pivot %d",
+        LOG ("now at least %" PRId64
+          " non-tautological resolvents on pivot %d",
           resolvents, pivot);
         if (size > opts.elimclslim) {
-          LOG ("resolvent size %d too big after %" PRId64 " resolvents on %d",
+          LOG ("resolvent size %d too big after %" PRId64
+            " resolvents on %d",
             size, resolvents, pivot);
           return false;
         }
@@ -412,7 +415,8 @@ Internal::elim_resolvents_are_bounded (Eliminator & eliminator, int pivot)
     }
   }
 
-  LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents", resolvents, bound);
+  LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents",
+    resolvents, bound);
 
   return true;
 }
@@ -448,7 +452,6 @@ Internal::elim_add_resolvents (Eliminator & eliminator, int pivot) {
       if (d->garbage) continue;
       if (substitute && c->gate == d->gate) continue;
       if (!resolve_clauses (eliminator, c, pivot, d)) continue;
-      assert (clause.size () <= (size_t) opts.elimclslim);
       Clause * r = new_resolved_irredundant_clause ();
       elim_update_added_clause (eliminator, r);
       eliminator.enqueue (r);
@@ -584,14 +587,13 @@ Internal::mark_redundant_clauses_with_eliminated_variables_as_garbage () {
 
 /*------------------------------------------------------------------------*/
 
-// Perform one round of bounded variable elimination and return 'false' if
-// no variable was eliminated even though elimination ran to completion.
-// Thus the result is 'false' iff elimination completed for this
-// particular elimination bound (which will trigger its increase) and it is
-// 'true' if at least one variable was eliminated or the resolution limit
-// was hit and elimination did not run to completion.
+// This function performs one round of bounded variable elimination and
+// returns the number of eliminated variables. The additional result
+// 'completed' is true if this elimination round ran to completion (all
+// variables have been tried).  Otherwise it was asynchronously terminated
+// or the resolution limit was hit.
 
-bool Internal::elim_round () {
+int Internal::elim_round (bool & completed) {
 
   assert (opts.elim);
   assert (!unsat);
@@ -616,8 +618,7 @@ bool Internal::elim_round () {
 
      resolution_limit = stats.elimres + delta;
   } else {
-    PHASE ("elim-round", stats.elimrounds,
-      "resolutions unlimited");
+    PHASE ("elim-round", stats.elimrounds, "resolutions unlimited");
     resolution_limit = LONG_MAX;
   }
 
@@ -636,7 +637,7 @@ bool Internal::elim_round () {
       else if (tmp < 0) falsified = true;
       else assert (active (lit));
     }
-    if (satisfied) mark_garbage (c);          // more precise counts
+    if (satisfied) mark_garbage (c);     // forces more precise counts
     else {
       for (const auto & lit : *c) {
         if (!active (lit)) continue;
@@ -647,15 +648,15 @@ bool Internal::elim_round () {
   }
 
   init_occs ();
+
   Eliminator eliminator (this);
   ElimSchedule & schedule = eliminator.schedule;
 
-  // Now find elimination candidates with small number of occurrences, which
-  // do not occur in too large clauses but do occur in clauses which have
-  // been removed since the last time we ran bounded variable elimination,
-  // which in turned triggered their 'elim' bit to be set.
+  // Now find elimination candidates which occurred in clauses removed since
+  // the last time we ran bounded variable elimination, which in turned
+  // triggered their 'elim' bit to be set.
   //
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     if (!active (idx)) continue;
     if (frozen (idx)) continue;
     if (!flags (idx).elim) continue;
@@ -693,13 +694,15 @@ bool Internal::elim_round () {
   //
   const int64_t garbage_limit = (2*stats.irrbytes/3) + (1<<20);
 
-  // Try eliminating variables according to the schedule.
+  // Main loops tries to eliminate variables according to the schedule. The
+  // schedule is updated dynamically and variables are potentially
+  // rescheduled to be tried again if they occur in a removed clause.
   //
 #ifndef QUIET
   int64_t tried = 0;
 #endif
   while (!unsat &&
-         !terminating () &&
+         !terminated_asynchronously () &&
          stats.elimres <= resolution_limit &&
          !schedule.empty ()) {
     int idx = schedule.front ();
@@ -714,12 +717,15 @@ bool Internal::elim_round () {
     garbage_collection ();
   }
 
-  const int64_t remain = schedule.size ();
-  const bool completed = !remain;
+  // If the schedule is empty all variables have been tried (even
+  // rescheduled ones).  Otherwise asynchronous termination happened or we
+  // ran into the resolution limit (or derived unsatisfiability).
+  //
+  completed = !schedule.size ();
 
   PHASE ("elim-round", stats.elimrounds,
-    "tried to eliminate %" PRId64 " variables %.0f%% (%" PRId64 " remain)",
-    tried, percent (tried, scheduled), remain);
+    "tried to eliminate %" PRId64 " variables %.0f%% (%zd remain)",
+    tried, percent (tried, scheduled), schedule.size ());
 
   schedule.erase ();
 
@@ -728,7 +734,7 @@ bool Internal::elim_round () {
   //
   Instantiator instantiator;
   if (!unsat &&
-      !terminating () &&
+      !terminated_asynchronously () &&
       opts.instantiate)
     collect_instantiation_candidates (instantiator);
 
@@ -754,18 +760,21 @@ bool Internal::elim_round () {
   STOP_SIMPLIFIER (elim, ELIM);
 
   if (!unsat &&
-      !terminating () &&
+      !terminated_asynchronously () &&
       instantiator)                     // Do we have candidate pairs?
     instantiate (instantiator);
 
-  return !completed || eliminated;
+  return eliminated;                    // non-zero if successful
 }
 
 /*------------------------------------------------------------------------*/
 
 // Increase elimination bound (additional clauses allowed during variable
 // elimination), which is triggered if elimination with last bound completed
-// (including no new subsumptions).
+// (including no new subsumptions).  This was pioneered by GlueMiniSAT in
+// the SAT Race 2015 and then picked up Chanseok Oh in his COMinisatPS
+// solver, which in turn is used in the Maple series of SAT solvers.
+// The bound is no increased if the maximum bound is reached.
 
 void Internal::increase_elimination_bound () {
 
@@ -784,13 +793,15 @@ void Internal::increase_elimination_bound () {
   // Now reschedule all active variables for elimination again.
   //
   int count = 0;
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     if (!active (idx)) continue;
     if (flags (idx).elim) continue;
     mark_elim (idx);
     count++;
   }
   LOG ("marked %d variables as elimination candidates", count);
+
+  report ('^');
 }
 
 /*------------------------------------------------------------------------*/
@@ -802,10 +813,13 @@ void Internal::elim (bool update_limits) {
   if (!propagate ()) { learn_empty_clause (); return; }
 
   stats.elimphases++;
+  PHASE ("elim-phase", stats.elimphases,
+    "starting at most %d elimination rounds",
+    opts.elimrounds);
 
 #ifndef QUIET
-  int old_eliminated = stats.all.eliminated;
   int old_active_variables = active ();
+  int old_eliminated = stats.all.eliminated;
 #endif
 
   // Make sure there was a complete subsumption phase since last
@@ -816,48 +830,67 @@ void Internal::elim (bool update_limits) {
 
   reset_watches ();             // saves lots of memory
 
-  // Alternate blocked clause elimination, variable elimination and
-  // subsumption, blocked and covered clause elimination until nothing
-  // changes or the round limit is hit.
-  //
-  bool completed = false, blocked = false, covered = false;
-  int round = 1;
-
-  while (!unsat && !terminating ()) {
-
-    if (elim_round ()) {        // Elimination successful or limit hit.
-
-      blocked = covered = false;        // Enable again.
+  // Alternate one round of bounded variable elimination ('elim_round') and
+  // subsumption ('subsume_round'), blocked ('block') and covered clause
+  // elimination ('cover') until nothing changes, or the round limit is hit.
+  // The loop also aborts early if no variable could be eliminated, the
+  // empty clause is resolved, it is asynchronously terminated or a
+  // resolution limit is hit.
 
-      if (round++ >= opts.elimrounds) break;
+  // This variable determines whether the whole loop of this bounded
+  // variable elimination phase ('elim') ran until completion.  This
+  // potentially triggers an incremental increase of the elimination bound.
+  //
+  bool phase_complete = false;
 
-      if (subsume_round ()) continue;   // New elimination candidates.
+  int round = 1;
 
-    } else {                    // Completed but nothing eliminated.
+  while (!unsat &&
+         !phase_complete &&
+         !terminated_asynchronously ()) {
 
-      completed = true;         // Triggers elimination bound increase.
+    bool round_complete;
 
-      if (round++ >= opts.elimrounds) break;
+#ifndef QUIET
+    int eliminated =
+#endif
+    elim_round (round_complete);
+
+    if (!round_complete) {
+      PHASE ("elim-phase", stats.elimphases,
+        "last round %d incomplete %s",
+        round, eliminated ? "but successful" : "and unsuccessful");
+      assert (!phase_complete);
+      break;
     }
 
-    if (!blocked) {
-      blocked = true;           // Only once per failed elimination
-      if (block ()) continue;   // At least one blocked clause.
+    if (round++ >= opts.elimrounds) {
+      PHASE ("elim-phase", stats.elimphases,
+        "round limit %d hit (%s)", round-1,
+        eliminated ? "though last round successful" :
+                     "last round unsuccessful anyhow");
+      assert (!phase_complete);
+      break;
     }
 
-    if (!covered) {
-      covered = true;           // Only once per failed elimination
-      if (cover ()) continue;   // At least one covered clause.
-    }
+    // Prioritize 'subsumption' over blocked and covered clause elimination.
+
+    if (subsume_round ()) continue;
+    if (block ()) continue;
+    if (cover ()) continue;
 
     // Was not able to generate new variable elimination candidates after
     // variable elimination round, neither through subsumption, nor blocked,
     // nor covered clause elimination.
     //
-    break;
+    PHASE ("elim-phase", stats.elimphases,
+      "no new variable elimination candidates");
+
+    assert (round_complete);
+    phase_complete = true;
   }
 
-  if (completed) {
+  if (phase_complete) {
     stats.elimcompleted++;
     PHASE ("elim-phase", stats.elimphases,
       "fully completed elimination %" PRId64
@@ -883,6 +916,11 @@ void Internal::elim (bool update_limits) {
     }
   }
 
+  // If we ran variable elimination until completion we increase the
+  // variable elimination bound and reschedule elimination of all variables.
+  //
+  if (phase_complete) increase_elimination_bound ();
+
 #ifndef QUIET
   int eliminated = stats.all.eliminated - old_eliminated;
   PHASE ("elim-phase", stats.elimphases,
@@ -890,8 +928,6 @@ void Internal::elim (bool update_limits) {
     eliminated, percent (eliminated, old_active_variables));
 #endif
 
-  if (completed) increase_elimination_bound ();
-
   if (!update_limits) return;
 
   int64_t delta = scale (opts.elimint * (stats.elimphases + 1));
diff --git a/src/extend.cpp b/src/extend.cpp
index f6797505..d84ba95a 100644
--- a/src/extend.cpp
+++ b/src/extend.cpp
@@ -133,7 +133,7 @@ void External::extend () {
         assert (i != begin);
     else {
       while ((lit = *--i)) {
-        const int tmp = ival (lit);		// not 'signed char'!!!
+        const int tmp = ival (lit);             // not 'signed char'!!!
         if (tmp < 0) {
           LOG ("flipping blocking literal %d", lit);
           assert (lit);
diff --git a/src/external.cpp b/src/external.cpp
index 83e1e216..2a37e5e8 100644
--- a/src/external.cpp
+++ b/src/external.cpp
@@ -9,7 +9,9 @@ External::External (Internal * i)
   vsize (0),
   extended (false),
   terminator (0),
-  solution (0)
+  learner (0),
+  solution (0),
+  vars (max_var)
 {
   assert (internal);
   assert (!internal->external);
@@ -36,7 +38,7 @@ void External::init (int new_max_var) {
   int new_vars = new_max_var - max_var;
   int old_internal_max_var = internal->max_var;
   int new_internal_max_var = old_internal_max_var + new_vars;
-  internal->init (new_internal_max_var);
+  internal->init_vars (new_internal_max_var);
   if ((size_t) new_max_var >= vsize) enlarge (new_max_var);
   LOG ("initialized %d external variables", new_vars);
   if (!max_var) {
@@ -48,20 +50,22 @@ void External::init (int new_max_var) {
     assert (e2i.size () == (size_t) max_var + 1);
     assert (internal->i2e.size () == (size_t) old_internal_max_var + 1);
   }
-  int iidx = old_internal_max_var + 1, eidx;
-  for (eidx = max_var + 1; eidx <= new_max_var; eidx++, iidx++) {
-    LOG ("mapping external %d to internal %d", eidx, iidx);
-    assert (e2i.size () == (size_t) eidx);
+  unsigned iidx = old_internal_max_var + 1, eidx;
+  for (eidx = max_var + 1u;
+       eidx <= (unsigned) new_max_var;
+       eidx++, iidx++) {
+    LOG ("mapping external %u to internal %u", eidx, iidx);
+    assert (e2i.size () == eidx);
     e2i.push_back (iidx);
     internal->i2e.push_back (eidx);
-    assert (internal->i2e[iidx] == eidx);
-    assert (e2i[eidx] == iidx);
+    assert (internal->i2e[iidx] == (int) eidx);
+    assert (e2i[eidx] == (int) iidx);
   }
   if (internal->opts.checkfrozen)
     while (new_max_var >= (int64_t) moltentab.size ())
       moltentab.push_back (false);
-  assert (iidx == new_internal_max_var + 1);
-  assert (eidx == new_max_var + 1);
+  assert (iidx == (size_t) new_internal_max_var + 1);
+  assert (eidx == (size_t) new_max_var + 1);
   max_var = new_max_var;
 }
 
@@ -93,8 +97,9 @@ int External::internalize (int elit) {
     ilit = e2i [eidx];
     if (elit < 0) ilit = -ilit;
     if (!ilit) {
-      ilit = internal->max_var + 1;
-      internal->init (ilit);
+      assert (internal->max_var < INT_MAX);
+      ilit = internal->max_var + 1u;
+      internal->init_vars (ilit);
       e2i[eidx] = ilit;
       LOG ("mapping external %d to internal %d", eidx, ilit);
       e2i[eidx] = ilit;
@@ -154,6 +159,28 @@ bool External::failed (int elit) {
   return internal->failed (ilit);
 }
 
+void External::phase (int elit) {
+  assert (elit);
+  assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var) return;
+  int ilit = e2i[eidx];
+  if (!ilit) return;
+  if (elit < 0) ilit = -ilit;
+  internal->phase (ilit);
+}
+
+void External::unphase (int elit) {
+  assert (elit);
+  assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var) return;
+  int ilit = e2i[eidx];
+  if (!ilit) return;
+  if (elit < 0) ilit = -ilit;
+  internal->unphase (ilit);
+}
+
 /*------------------------------------------------------------------------*/
 
 // Internal checker if 'solve' claims the formula to be satisfiable.
@@ -189,9 +216,9 @@ void External::check_solve_result (int res) {
 
 void External::update_molten_literals () {
   if (!internal->opts.checkfrozen) return;
-  assert (max_var + 1 == (int64_t) moltentab.size ());
+  assert ((size_t) max_var + 1 == moltentab.size ());
   int registered = 0, molten = 0;
-  for (int lit = 1; lit <= max_var; lit++) {
+  for (auto lit : vars) {
     if (moltentab[lit]) {
       LOG ("skipping already molten literal %d", lit);
       molten++;
@@ -208,10 +235,10 @@ void External::update_molten_literals () {
   LOG ("reached in total %d molten literals", molten);
 }
 
-int External::solve () {
+int External::solve (bool preprocess_only) {
   reset_extended ();
   update_molten_literals ();
-  int res = internal->solve ();
+  int res = internal->solve (preprocess_only);
   if (res == 10) extend ();
   check_solve_result (res);
   reset_limits ();
@@ -220,6 +247,34 @@ int External::solve () {
 
 void External::terminate () { internal->terminate (); }
 
+int External::lookahead () {
+  reset_extended ();
+  update_molten_literals ();
+  int ilit = internal->lookahead ();
+  const int elit = (ilit && ilit != INT_MIN) ? internal->externalize (ilit) : 0;
+  LOG ("lookahead internal %d external %d", ilit, elit);
+  return elit;
+}
+
+CaDiCaL::CubesWithStatus External::generate_cubes (int depth) {
+  reset_extended ();
+  update_molten_literals ();
+  reset_limits ();
+  auto cubes {internal->generate_cubes (depth)};
+  auto externalize = [this](int ilit) {
+    const int elit = ilit ? internal->externalize (ilit) : 0;
+    MSG ("lookahead internal %d external %d", ilit, elit);
+    return elit;
+  };
+  auto externalize_map = [this, externalize](std::vector<int> cube) {
+    MSG("Cube : ");
+    std::for_each(begin(cube), end(cube), externalize);
+  };
+    std::for_each(begin(cubes.cubes), end(cubes.cubes), externalize_map);
+
+    return cubes;
+}
+
 /*------------------------------------------------------------------------*/
 
 void External::freeze (int elit) {
@@ -263,7 +318,7 @@ void External::check_assignment (int (External::*a)(int) const) {
 
   // First check all assigned and consistent.
   //
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     if (!(this->*a) (idx)) FATAL ("unassigned variable: %d", idx);
     if ((this->*a) (idx) != -(this->*a)(-idx))
       FATAL ("inconsistently assigned literals %d and %d", idx, -idx);
@@ -279,12 +334,12 @@ void External::check_assignment (int (External::*a)(int) const) {
     int lit = *i;
     if (!lit) {
       if (!satisfied) {
-        internal->fatal_message_start ();
+        fatal_message_start ();
         fputs ("unsatisfied clause:\n", stderr);
         for (auto j = start; j != i; j++)
           fprintf (stderr, "%d ", *j);
         fputc ('0', stderr);
-        internal->fatal_message_end ();
+        fatal_message_end ();
       }
       satisfied = false;
       start = i + 1;
@@ -301,7 +356,7 @@ void External::check_assignment (int (External::*a)(int) const) {
 void External::check_assumptions_satisfied () {
   for (const auto & lit : assumptions) {
     // Not 'signed char' !!!!
-    const int tmp = ival (lit);				
+    const int tmp = ival (lit);
     if (tmp < 0) FATAL ("assumption %d falsified", lit);
     if (!tmp) FATAL ("assumption %d unassigned", lit);
   }
@@ -340,7 +395,7 @@ bool External::traverse_all_frozen_units_as_clauses (ClauseIterator & it) {
 
   vector<int> clause;
 
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     const int tmp = fixed (idx);
     if (!tmp) continue;
     if (!frozen (idx)) continue;
@@ -363,7 +418,7 @@ External::traverse_all_non_frozen_units_as_witnesses (WitnessIterator & it)
 
   vector<int> clause_and_witness;
 
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     if (frozen (idx)) continue;
     const int tmp = fixed (idx);
     if (!tmp) continue;
@@ -377,4 +432,64 @@ External::traverse_all_non_frozen_units_as_witnesses (WitnessIterator & it)
   return true;
 }
 
+/*------------------------------------------------------------------------*/
+
+void External::copy_flags (External & other) const {
+  const vector<Flags> & this_ftab = internal->ftab;
+  vector<Flags> & other_ftab = other.internal->ftab;
+  const unsigned limit = min (max_var, other.max_var);
+  for (unsigned eidx = 1; eidx <= limit; eidx++) {
+    const int this_ilit = e2i[eidx];
+    if (!this_ilit) continue;
+    const int other_ilit = other.e2i[eidx];
+    if (!other_ilit) continue;
+    if (!internal->active (this_ilit)) continue;
+    if (!other.internal->active (other_ilit)) continue;
+    assert (this_ilit != INT_MIN);
+    assert (other_ilit != INT_MIN);
+    const Flags & this_flags = this_ftab[abs (this_ilit)];
+    Flags & other_flags = other_ftab[abs (other_ilit)];
+    this_flags.copy (other_flags);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::export_learned_empty_clause () {
+  assert (learner);
+  if (learner->learning (0)) {
+    LOG ("exporting learned empty clause");
+    learner->learn (0);
+  } else
+    LOG ("not exporting learned empty clause");
+}
+
+void External::export_learned_unit_clause (int ilit) {
+  assert (learner);
+  if (learner->learning (1)) {
+    LOG ("exporting learned unit clause");
+    const int elit = internal->externalize (ilit);
+    assert (elit);
+    learner->learn (elit);
+    learner->learn (0);
+  } else
+    LOG ("not exporting learned unit clause");
+}
+
+void External::export_learned_large_clause (const vector<int> & clause) {
+  assert (learner);
+  size_t size = clause.size ();
+  assert (size <= (unsigned) INT_MAX);
+  if (learner->learning ((int) size)) {
+    LOG ("exporting learned clause of size %zu", size);
+    for (auto ilit : clause) {
+      const int elit = internal->externalize (ilit);
+      assert (elit);
+      learner->learn (elit);
+    }
+    learner->learn (0);
+  } else
+    LOG ("not exporting learned clause of size %zu", size);
+}
+
 }
diff --git a/src/external.hpp b/src/external.hpp
index d6ee42ce..ba8b4a33 100644
--- a/src/external.hpp
+++ b/src/external.hpp
@@ -3,6 +3,10 @@
 
 /*------------------------------------------------------------------------*/
 
+#include "range.hpp"
+
+/*------------------------------------------------------------------------*/
+
 namespace CaDiCaL {
 
 using namespace std;
@@ -18,11 +22,11 @@ using namespace std;
 // Note, that 'Solver' is defined in 'cadical.hpp' and 'solver.cpp', while
 // 'External' and 'Internal' in '{external,internal}.{hpp,cpp}'.
 //
-// Also note, that 'App' accesses (and any user of the library should
-// access) the library only through the 'Solver' API.  For the library
-// internal 'Parser' code we make an exception and allow access to both
-// 'External' and 'Internal'.  The former to enforce the same external to
-// internal mapping of variables and the latter for profiling and messages.
+// Also note, that any user should access the library only through the
+// 'Solver' API.  For the library internal 'Parser' code we make an
+// exception and allow access to both 'External' and 'Internal'.  The former
+// to enforce the same external to internal mapping of variables and the
+// latter for profiling and messages.  The same applies to 'App'.
 //
 // The 'External' class provided here stores the information needed to map
 // external variable indices to internal variables (actually literals).
@@ -38,24 +42,72 @@ using namespace std;
 
 struct Clause;
 struct Internal;
+struct CubesWithStatus;
+
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
 
 struct External {
 
-  /*----------------------------------------------------------------------*/
+  /*==== start of state ==================================================*/
 
-  typedef signed char signed_char;
+  Internal * internal;        // The actual internal solver.
 
-  /*----------------------------------------------------------------------*/
+  int max_var;                // External maximum variable index.
+  size_t vsize;               // Allocated external size.
 
-  Internal * internal;    // The actual internal solver.
-  int max_var;            // External maximum variable index.
-  size_t vsize;
-  vector<bool> vals;      // Current external (extended) assignment.
-  vector<int> e2i;        // External 'idx' to internal 'lit' [1,max_var].
+  vector<bool> vals;          // Current external (extended) assignment.
+  vector<int> e2i;            // External 'idx' to internal 'lit'.
 
-  vector<int> assumptions;      // External assumptions.
+  vector<int> assumptions;    // External assumptions.
 
-  /*----------------------------------------------------------------------*/
+  // The extension stack for reconstructing complete satisfying assignments
+  // (models) of the original external formula is kept in this external
+  // solver object. It keeps track of blocked clauses and clauses containing
+  // eliminated variable.  These irredundant clauses are stored in terms of
+  // external literals on the 'extension' stack after mapping the
+  // internal literals given as arguments with 'externalize'.
+
+  bool extended;              // Have been extended.
+  vector<int> extension;      // Solution reconstruction extension stack.
+
+  vector<bool> witness;       // Literal witness on extension stack.
+  vector<bool> tainted;       // Literal tainted in adding literals.
+
+  vector<unsigned> frozentab; // Reference counts for frozen variables.
+
+  // Regularly checked terminator if non-zero.  The terminator is set from
+  // 'Solver::set (Terminator *)' and checked by 'Internal::terminating ()'.
+
+  Terminator * terminator;
+
+  // If there is a learner export learned clauses.
+
+  Learner * learner;
+
+  void export_learned_empty_clause ();
+  void export_learned_unit_clause (int ilit);
+  void export_learned_large_clause (const vector<int> &);
+
+  //----------------------------------------------------------------------//
+
+  signed char * solution;     // Given solution checking for debugging.
+  vector<int> original;       // Saved original formula for checking.
+
+  // If 'opts.checkfrozen' is set make sure that only literals are added
+  // which were never completely molten before.  These molten literals are
+  // marked at the beginning of the 'solve' call.  Note that variables
+  // larger than 'max_var' are not molten and can thus always be used in the
+  // future.  Only needed to check and debug old style freeze semantics.
+  //
+  vector<bool> moltentab;
+
+  //----------------------------------------------------------------------//
+
+  const Range vars;           // Provides safe variable iterations.
+
+  /*==== end of state ====================================================*/
 
   // These two just factor out common sanity (assertion) checking code.
 
@@ -76,16 +128,6 @@ struct External {
 
   /*----------------------------------------------------------------------*/
 
-  // The extension stack for reconstructing complete satisfying assignments
-  // (models) of the original external formula is kept in this external
-  // solver object. It keeps track of blocked clauses and clauses containing
-  // eliminated variable.  These irredundant clauses are stored in terms of
-  // external literals on the 'extension' stack after mapping the
-  // internal literals given as arguments with 'externalize'.
-
-  bool extended;          // Have been extended.
-  vector<int> extension;  // Extension stack for reconstructing solutions.
-
   // The following five functions push individual literals or clauses on the
   // extension stack.  They all take internal literals as argument, and map
   // them back to external literals first, before pushing them on the stack.
@@ -137,16 +179,12 @@ struct External {
     if (ulit < map.size ()) map[ulit] = false;
   }
 
-  vector<bool> witness;
-  vector<bool> tainted;
-
   /*----------------------------------------------------------------------*/
 
   void push_external_clause_and_witness_on_extension_stack (
     const vector<int> & clause, const vector<int> & witness);
 
   // Restore a clause, which was pushed on the extension stack.
-  //
   void restore_clause (
     const vector<int>::const_iterator & begin,
     const vector<int>::const_iterator & end);
@@ -159,8 +197,6 @@ struct External {
   // internally and implicitly assumed literals).  Passes on freezing and
   // melting to the internal solver, which has separate frozen counters.
 
-  vector<unsigned> frozentab;
-
   void freeze (int elit);
   void melt (int elit);
 
@@ -173,13 +209,6 @@ struct External {
     return frozentab[eidx] > 0;
   }
 
-  // Used if 'checkfrozen' is set to make sure that only literals are added
-  // which were never completely molten before.  These molten literals are
-  // marked at the beginning of the 'solve' call.  Note that variables
-  // larger than 'max_var' are not molten and can be used in the future.
-  //
-  vector<bool> moltentab;
-
   /*----------------------------------------------------------------------*/
 
   External (Internal *);
@@ -222,13 +251,13 @@ struct External {
 
   void add (int elit);
   void assume (int elit);
-  int solve ();
-  void terminate ();
+  int solve (bool preprocess_only);
+
 
   // We call it 'ival' as abbreviation for 'val' with 'int' return type to
   // avoid bugs due to using 'signed char tmp = val (lit)', which might turn
   // a negative value into a positive one (happened in 'extend').
-  // 
+  //
   inline int ival (int elit) const {
     assert (elit != INT_MIN);
     int eidx = abs (elit), res;
@@ -239,36 +268,42 @@ struct External {
     return res;
   }
 
+  bool failed (int elit);
+
+  void terminate ();
+
+  // Other important non IPASIR functions.
+
+  int lookahead();
+  CaDiCaL::CubesWithStatus generate_cubes(int);
+
   int fixed (int elit) const;   // Implemented in 'internal.hpp'.
 
-  bool failed (int elit);
+  /*----------------------------------------------------------------------*/
+
+  void phase (int elit);
+  void unphase (int elit);
 
   /*----------------------------------------------------------------------*/
 
-  // Regularly checked terminator if non-zero.  The terminator is set from
-  // 'Solver::set (Terminator *)' and checked by 'Internal::terminating ()'.
+  // Traversal functions.
 
-  Terminator * terminator;
+  bool traverse_all_frozen_units_as_clauses (ClauseIterator &);
+  bool traverse_all_non_frozen_units_as_witnesses (WitnessIterator &);
+  bool traverse_witnesses_backward (WitnessIterator &);
+  bool traverse_witnesses_forward (WitnessIterator &);
 
   /*----------------------------------------------------------------------*/
 
-  signed char * solution; // For checking & debugging [1,max_var]
-  vector<int> original;   // Saved original formula for checking.
+  // Copy flags for determining preprocessing state.
+
+  void copy_flags (External & other) const;
 
-  // For debugging and testing only.  See 'solution.hpp' for more details.
-  //
-  inline int sol (int elit) const {
-    assert (solution);
-    assert (elit != INT_MIN);
-    int eidx = abs (elit);
-    if (eidx > max_var) return 0;
-    int res = solution[eidx];
-    if (elit < 0) res = -res;
-    return res;
-  }
 
   /*----------------------------------------------------------------------*/
 
+  // Check solver behaves as expected during testing and debugging.
+
   void check_assumptions_satisfied ();
   void check_assumptions_failing ();
 
@@ -304,12 +339,17 @@ struct External {
 
   /*----------------------------------------------------------------------*/
 
-  // Traversal functions.
-
-  bool traverse_all_frozen_units_as_clauses (ClauseIterator &);
-  bool traverse_all_non_frozen_units_as_witnesses (WitnessIterator &);
-  bool traverse_witnesses_backward (WitnessIterator &);
-  bool traverse_witnesses_forward (WitnessIterator &);
+  // For debugging and testing only.  See 'solution.hpp' for more details.
+  //
+  inline int sol (int elit) const {
+    assert (solution);
+    assert (elit != INT_MIN);
+    int eidx = abs (elit);
+    if (eidx > max_var) return 0;
+    int res = solution[eidx];
+    if (elit < 0) res = -res;
+    return res;
+  }
 };
 
 }
diff --git a/src/flags.hpp b/src/flags.hpp
index 6b08ba33..eed87252 100644
--- a/src/flags.hpp
+++ b/src/flags.hpp
@@ -16,13 +16,13 @@ struct Flags {        // Variable flags.
   // ('subsume'), variables in bounded variable elimination ('elim') and in
   // hyper ternary resolution ('ternary').
   //
-  bool elim      : 1; // removed since last 'elim' round
-  bool subsume   : 1; // added since last 'subsume' round
-  bool ternary   : 1; // added in ternary clause since last 'ternary'
+  bool elim      : 1; // removed since last 'elim' round (*)
+  bool subsume   : 1; // added since last 'subsume' round (*)
+  bool ternary   : 1; // added in ternary clause since last 'ternary' (*)
 
   // These literal flags are used by blocked clause elimination ('block').
   //
-  unsigned char block : 2;   // removed since last 'block' round
+  unsigned char block : 2;   // removed since last 'block' round (*)
   unsigned char skip : 2;    // skip this literal as blocking literal
 
   // Bits for handling assumptions.
@@ -57,6 +57,17 @@ struct Flags {        // Variable flags.
   bool eliminated () const { return status == ELIMINATED; }
   bool substituted () const { return status == SUBSTITUTED; }
   bool pure () const { return status == PURE; }
+
+  // The flags marked with '(*)' are copied during 'External::copy_flags',
+  // which in essence means they are reset in the copy if they were clear.
+  // This avoids the effort of fruitless preprocessing the copy.
+
+  void copy (Flags & dst) const {
+    dst.elim = elim;
+    dst.subsume = subsume;
+    dst.ternary = ternary;
+    dst.block = block;
+  }
 };
 
 }
diff --git a/src/gates.cpp b/src/gates.cpp
index f3500977..ae634630 100644
--- a/src/gates.cpp
+++ b/src/gates.cpp
@@ -280,8 +280,7 @@ bool Internal::get_ternary_clause (Clause * d, int & a, int & b, int & c)
   return found == 3;
 }
 
-// This function checks whether 'd' exists as ternary clause or as a binary
-// clause subsuming 'd' (contains only the given literals).
+// This function checks whether 'd' exists as ternary clause.
 
 bool Internal::match_ternary_clause (Clause * d, int a, int b, int c) {
   if (d->garbage) return false;
diff --git a/src/instantiate.cpp b/src/instantiate.cpp
index 661cc3f8..c1b5b9b3 100644
--- a/src/instantiate.cpp
+++ b/src/instantiate.cpp
@@ -14,7 +14,7 @@ namespace CaDiCaL {
 void
 Internal::collect_instantiation_candidates (Instantiator & instantiator) {
   assert (occurring ());
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     if (frozen (idx)) continue;
     if (!active (idx)) continue;
     if (flags (idx).elim) continue;               // BVE attempt pending
@@ -213,7 +213,7 @@ void Internal::instantiate (Instantiator & instantiator) {
     "attempting to instantiate %zd candidate literal clause pairs",
     candidates);
   while (!unsat &&
-         !terminating () &&
+         !terminated_asynchronously () &&
          !instantiator.candidates.empty ()) {
     Instantiator::Candidate cand = instantiator.candidates.back ();
     instantiator.candidates.pop_back ();
diff --git a/src/internal.cpp b/src/internal.cpp
index 32b6741d..521c2833 100644
--- a/src/internal.cpp
+++ b/src/internal.cpp
@@ -10,9 +10,10 @@ Internal::Internal ()
   unsat (false),
   iterating (false),
   localsearching (false),
+  lookingahead (false),
   preprocessing (false),
+  protected_reasons (false),
   force_saved_phase (false),
-  termination_forced (false),
   searching_lucky_phases (false),
   stable (false),
   reported (false),
@@ -21,7 +22,7 @@ Internal::Internal ()
   max_var (0),
   level (0),
   vals (0),
-  scinc (1.0),
+  score_inc (1.0),
   scores (this),
   conflict (0),
   ignore (0),
@@ -41,11 +42,12 @@ Internal::Internal ()
   arena (this),
   prefix ("c "),
   internal (this),
-  external (0)
+  external (0),
+  termination_forced (false),
+  vars (this->max_var),
+  lits (this->max_var)
 {
   control.push_back (Level (0, 0));
-  binary_subsuming.redundant = false;
-  binary_subsuming.size = 2;
 }
 
 Internal::~Internal () {
@@ -83,7 +85,7 @@ void Internal::enlarge_vals (size_t new_vsize) {
   ignore_clang_analyze_memory_leak_warning = new_vals;
   new_vals += new_vsize;
 
-  if (vals) memcpy (new_vals - max_var, vals - max_var, 2*max_var + 1);
+  if (vals) memcpy (new_vals - max_var, vals - max_var, 2u*max_var + 1u);
   vals -= vsize;
   delete [] vals;
   vals = new_vals;
@@ -118,6 +120,7 @@ void Internal::enlarge (int new_max_var) {
   // Ordered in the size of allocated memory (larger block first).
   enlarge_only (wtab, 2*new_vsize);
   enlarge_only (vtab, new_vsize);
+  enlarge_zero (parents, new_vsize);
   enlarge_only (links, new_vsize);
   enlarge_zero (btab, new_vsize);
   enlarge_zero (gtab, new_vsize);
@@ -128,6 +131,7 @@ void Internal::enlarge (int new_max_var) {
   enlarge_zero (frozentab, new_vsize);
   const signed char val = opts.phase ? 1 : -1;
   enlarge_init (phases.saved, new_vsize, val);
+  enlarge_zero (phases.forced, new_vsize);
   enlarge_zero (phases.target, new_vsize);
   enlarge_zero (phases.best, new_vsize);
   enlarge_zero (phases.prev, new_vsize);
@@ -136,18 +140,22 @@ void Internal::enlarge (int new_max_var) {
   vsize = new_vsize;
 }
 
-void Internal::init (int new_max_var) {
+void Internal::init_vars (int new_max_var) {
   if (new_max_var <= max_var) return;
   if (level) backtrack ();
   LOG ("initializing %d internal variables from %d to %d",
     new_max_var - max_var, max_var + 1, new_max_var);
   if ((size_t) new_max_var >= vsize) enlarge (new_max_var);
 #ifndef NDEBUG
-  for (int i = -new_max_var; i < -max_var; i++) assert (!vals[i]);
-  for (int i = max_var + 1; i <= new_max_var; i++) assert (!vals[i]);
-  for (int i = max_var + 1; i <= new_max_var; i++) assert (!btab[i]);
-  for (int i = max_var + 1; i <= new_max_var; i++) assert (!gtab[i]);
-  for (int i = 2*(max_var + 1); i <= 2*new_max_var+1; i++)
+  for (int64_t i = -new_max_var; i < -max_var; i++) assert (!vals[i]);
+  for (unsigned i = max_var + 1; i <= (unsigned) new_max_var; i++)
+    assert (!vals[i]);
+  for (unsigned i = max_var + 1; i <= (unsigned) new_max_var; i++)
+    assert (!btab[i]);
+  for (unsigned i = max_var + 1; i <= (unsigned) new_max_var; i++)
+  for (uint64_t i = 2*((uint64_t)max_var + 1);
+       i <= 2*(uint64_t)new_max_var + 1;
+       i++)
     assert (ptab[i] == -1);
 #endif
   assert (!btab[0]);
@@ -191,7 +199,9 @@ int Internal::cdcl_loop_with_inprocessing () {
     else if (!propagate ()) analyze ();      // propagate and analyze
     else if (iterating) iterate ();          // report learned unit
     else if (satisfied ()) res = 10;         // found model
-    else if (terminating ()) break;          // limit hit or async abort
+    else if (search_limits_hit ()) break;    // decision or conflict limit
+    else if (terminated_asynchronously ())    // externally terminated
+      break;
     else if (restarting ()) restart ();      // restart by backtracking
     else if (rephasing ()) rephase ();       // reset variable phases
     else if (reducing ()) reduce ();         // collect useless clauses
@@ -217,40 +227,22 @@ int Internal::cdcl_loop_with_inprocessing () {
 // increased as in a stand-alone non-incremental SAT call except for those
 // explicitly marked as being reset below.
 
-void Internal::init_limits () {
+void Internal::init_report_limits () {
+  reported = false;
+  lim.report = 0;
+}
+
+void Internal::init_preprocessing_limits () {
 
   const bool incremental = lim.initialized;
-  if (incremental) LOG ("reinitializing limits incrementally");
-  else LOG ("initializing limits and increments");
+  if (incremental)
+    LOG ("reinitializing preprocessing limits incrementally");
+  else LOG ("initializing preprocessing limits and increments");
 
   const char * mode = 0;
 
   /*----------------------------------------------------------------------*/
 
-  if (incremental) mode = "keeping";
-  else {
-    last.reduce.conflicts = -1;
-    lim.reduce = stats.conflicts + opts.reduceint;
-    mode = "initial";
-  }
-  (void) mode;
-  LOG ("%s reduce limit %" PRId64 " after %" PRId64 " conflicts",
-    mode, lim.reduce, lim.reduce - stats.conflicts);
-
-  /*----------------------------------------------------------------------*/
-
-  if (incremental) mode = "keeping";
-  else {
-    lim.flush = opts.flushint;
-    inc.flush = opts.flushint;
-    mode = "initial";
-  }
-  (void) mode;
-  LOG ("%s flush limit %" PRId64 " interval %" PRId64 "",
-    mode, lim.flush, inc.flush);
-
-  /*----------------------------------------------------------------------*/
-
   if (incremental) mode = "keeping";
   else {
     lim.subsume = stats.conflicts + scale (opts.subsumeint);
@@ -279,6 +271,17 @@ void Internal::init_limits () {
 
   /*----------------------------------------------------------------------*/
 
+  if (!incremental) {
+
+    last.ternary.marked = -1;   // TODO explain why this is necessary.
+
+    lim.compact = stats.conflicts + opts.compactint;
+    LOG ("initial compact limit %" PRId64 " increment %" PRId64 "",
+      lim.compact, lim.compact - stats.conflicts);
+  }
+
+  /*----------------------------------------------------------------------*/
+
   if (incremental) mode = "keeping";
   else {
     lim.probe = stats.conflicts + opts.probeint;
@@ -290,24 +293,59 @@ void Internal::init_limits () {
 
   /*----------------------------------------------------------------------*/
 
-  if (!incremental) {
+  if (incremental) mode = "keeping";
+  else {
+    lim.condition = stats.conflicts + opts.conditionint;
+    mode = "initial";
+  }
+  LOG ("%s condition limit %ld increment %ld",
+    mode, lim.condition, lim.condition - stats.conflicts);
 
-    last.ternary.marked = -1;   // TODO explain why this is necessary.
+  /*----------------------------------------------------------------------*/
 
-    lim.compact = stats.conflicts + opts.compactint;
-    LOG ("initial compact limit %" PRId64 " increment %" PRId64 "",
-      lim.compact, lim.compact - stats.conflicts);
+  // Initial preprocessing rounds.
+
+  if (inc.preprocessing <= 0) {
+    lim.preprocessing = 0;
+    LOG ("no preprocessing");
+  } else {
+    lim.preprocessing = inc.preprocessing;
+    LOG ("limiting to %d preprocessing rounds", lim.preprocessing);
   }
 
+}
+
+void Internal::init_search_limits () {
+
+  const bool incremental = lim.initialized;
+  if (incremental) LOG ("reinitializing search limits incrementally");
+  else LOG ("initializing search limits and increments");
+
+  const char * mode = 0;
+
   /*----------------------------------------------------------------------*/
 
   if (incremental) mode = "keeping";
   else {
-    lim.condition = stats.conflicts + opts.conditionint;
+    last.reduce.conflicts = -1;
+    lim.reduce = stats.conflicts + opts.reduceint;
     mode = "initial";
   }
-  LOG ("%s condition limit %ld increment %ld",
-    mode, lim.condition, lim.condition - stats.conflicts);
+  (void) mode;
+  LOG ("%s reduce limit %" PRId64 " after %" PRId64 " conflicts",
+    mode, lim.reduce, lim.reduce - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental) mode = "keeping";
+  else {
+    lim.flush = opts.flushint;
+    inc.flush = opts.flushint;
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s flush limit %" PRId64 " interval %" PRId64 "",
+    mode, lim.flush, inc.flush);
 
   /*----------------------------------------------------------------------*/
 
@@ -328,13 +366,6 @@ void Internal::init_limits () {
 
   /*----------------------------------------------------------------------*/
 
-  // Initialize or reset 'report' limits in any case.
-
-  reported = false;
-  lim.report = 0;
-
-  /*----------------------------------------------------------------------*/
-
   if (!incremental) {
     stable = opts.stabilize && opts.stabilizeonly;
     if (stable) LOG ("starting in always forced stable phase");
@@ -384,15 +415,7 @@ void Internal::init_limits () {
 
   /*----------------------------------------------------------------------*/
 
-  // Initial preprocessing and local search rounds.
-
-  if (inc.preprocessing <= 0) {
-    lim.preprocessing = 0;
-    LOG ("no preprocessing");
-  } else {
-    lim.preprocessing = inc.preprocessing;
-    LOG ("limiting to %d preprocessing rounds", lim.preprocessing);
-  }
+  // Initial preprocessing rounds.
 
   if (inc.localsearch <= 0) {
     lim.localsearch = 0;
@@ -443,10 +466,9 @@ bool Internal::preprocess_round (int round) {
 }
 
 int Internal::preprocess () {
-  if (opts.simplify)
-    for (int i = 0; i < lim.preprocessing; i++)
-      if (!preprocess_round (i))
-        break;
+  for (int i = 0; i < lim.preprocessing; i++)
+    if (!preprocess_round (i))
+      break;
   if (unsat) return 20;
   return 0;
 }
@@ -554,59 +576,111 @@ int Internal::local_search () {
 
 /*------------------------------------------------------------------------*/
 
-int Internal::solve () {
+int Internal::solve (bool preprocess_only) {
   assert (clause.empty ());
   START (solve);
-  if (level) backtrack ();
+  if (preprocess_only) LOG ("internal solving in preprocessing only mode");
+  else LOG ("internal solving in full mode");
+  init_report_limits ();
+  int res = already_solved ();
+  if (!res) res = restore_clauses ();
+  if (!res) {
+    init_preprocessing_limits ();
+    if (!preprocess_only) init_search_limits ();
+  }
+  if (!res) res = preprocess ();
+  if (!preprocess_only) {
+    if (!res) res = local_search ();
+    if (!res) res = lucky_phases ();
+    if (!res) res = cdcl_loop_with_inprocessing ();
+  }
+  reset_solving ();
+  report_solving (res);
+  STOP (solve);
+  return res;
+}
+
+int Internal::already_solved () {
   int res = 0;
   if (unsat) {
     LOG ("already inconsistent");
     res = 20;
-  } else if (!propagate ()) {
-    LOG ("root level propagation produces conflict");
-    learn_empty_clause ();
-    res = 20;
   } else {
-
-    init_limits ();
-
-    if (opts.restoreall <= 1 &&
-        external->tainted.empty ()) {
-      LOG ("no tainted literals and nothing to restore");
-      report ('*');
-    } else {
-      report ('+');
-      external->restore_clauses ();
-      internal->report ('r');
-      if (!unsat && !propagate ()) {
-        LOG ("root level propagation after restore produces conflict");
-        learn_empty_clause ();
-        res = 20;
-      }
-    }
-
-    if (!res) res = preprocess ();
-    if (!res) res = local_search ();
-    if (!res) res = lucky_phases ();
-    if (!res) {
-      if (terminating ()) res = 0;
-      else res = cdcl_loop_with_inprocessing ();
+    if (level) backtrack ();
+    if (!propagate ()) {
+      LOG ("root level propagation produces conflict");
+      learn_empty_clause ();
+      res = 20;
     }
+    if(max_var == 0 && res == 0)
+      res = 10;
   }
+  return res;
+}
+void Internal::report_solving (int res) {
+       if (res == 10) report ('1');
+  else if (res == 20) report ('0');
+  else                report ('?');
+}
+
+void Internal::reset_solving () {
   if (termination_forced) {
+
+    // TODO this leads potentially to a data race if the external
+    // user is calling 'terminate' twice within one 'solve' call.
+    // A proper solution would be to guard / protect setting the
+    // 'termination_forced' flag and only allow it during solving and
+    // ignore it otherwise thus also the second time it is called during a
+    // 'solve' call.  We could move resetting it also the start of
+    // 'solve'.
+    //
     termination_forced = false;
+
     LOG ("reset forced termination");
   }
-       if (res == 10) report ('1');
-  else if (res == 20) report ('0');
-  else                report ('?');
-  STOP (solve);
+}
+
+int Internal::restore_clauses () {
+  int res = 0;
+  if (opts.restoreall <= 1 &&
+      external->tainted.empty ()) {
+    LOG ("no tainted literals and nothing to restore");
+    report ('*');
+  } else {
+    report ('+');
+    external->restore_clauses ();
+    internal->report ('r');
+    if (!unsat && !propagate ()) {
+      LOG ("root level propagation after restore produces conflict");
+      learn_empty_clause ();
+      res = 20;
+    }
+  }
+  return res;
+}
+
+
+int Internal::lookahead () {
+  assert (clause.empty ());
+  START (lookahead);
+  assert (!lookingahead);
+  lookingahead = true;
+  int tmp = already_solved ();
+  if (!tmp) tmp = restore_clauses ();
+  int res = 0;
+  if (!tmp) res = lookahead_probing ();
+  if (res == INT_MIN) res = 0;
+  reset_solving ();
+  report_solving (tmp);
+  assert (lookingahead);
+  lookingahead = false;
+  STOP(lookahead);
   return res;
 }
 
 /*------------------------------------------------------------------------*/
 
-void Internal::print_stats () {
+void Internal::print_statistics () {
   stats.print (this);
   if (checker) checker->print_stats ();
 }
@@ -623,12 +697,12 @@ void Internal::dump (Clause * c) {
 
 void Internal::dump () {
   int64_t m = assumptions.size ();
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     if (fixed (idx)) m++;
   for (const auto & c : clauses)
     if (!c->garbage) m++;
   printf ("p cnf %d %" PRId64 "\n", max_var, m);
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     const int tmp = fixed (idx);
     if (tmp) printf ("%d 0\n", tmp < 0 ? -idx : idx);
   }
diff --git a/src/internal.hpp b/src/internal.hpp
index 5812e89a..1c85d4ab 100644
--- a/src/internal.hpp
+++ b/src/internal.hpp
@@ -73,6 +73,7 @@ extern "C" {
 #include "queue.hpp"
 #include "radix.hpp"
 #include "random.hpp"
+#include "range.hpp"
 #include "reluctant.hpp"
 #include "resources.hpp"
 #include "score.hpp"
@@ -95,6 +96,11 @@ struct Coveror;
 struct External;
 struct Walker;
 
+struct CubesWithStatus {
+  int status;
+  std::vector<std::vector<int>> cubes;
+};
+
 /*------------------------------------------------------------------------*/
 
 struct Internal {
@@ -122,8 +128,6 @@ struct Internal {
     WALK     = (1<<14),
   };
 
-  int mode;
-
   bool in_mode (Mode m) const { return (mode & m) != 0; }
   void set_mode (Mode m) { assert (!(mode & m)); mode |= m; }
   void reset_mode (Mode m) { assert (mode & m); mode &= ~m; }
@@ -131,12 +135,14 @@ struct Internal {
 
   /*----------------------------------------------------------------------*/
 
+  int mode;                     // current internal state
   bool unsat;                   // empty clause found or learned
   bool iterating;               // report learned unit ('i' line)
   bool localsearching;          // true during local search
+  bool lookingahead;		// true during look ahead
   bool preprocessing;           // true during preprocessing
+  bool protected_reasons;       // referenced reasons are protected
   bool force_saved_phase;       // force saved phase in decision
-  bool termination_forced;      // forced to terminate
   bool searching_lucky_phases;  // during 'lucky_phases'
   bool stable;                  // true during stabilization phase
   bool reported;                // reported in this solving call
@@ -145,24 +151,24 @@ struct Internal {
   size_t vsize;                 // actually allocated variable data size
   int max_var;                  // internal maximum variable index
   int level;                    // decision level ('control.size () - 1')
+  Phases phases;                // saved, target and best phases
   signed char * vals;           // assignment [-max_var,max_var]
   vector<signed char> marks;    // signed marks [1,max_var]
-  Phases phases;                // saved, target and best phases
   vector<unsigned> frozentab;   // frozen counters [1,max_var]
-  vector<int> i2e;              // maps internal idx to external lit
+  vector<int> i2e;              // maps internal 'idx' to external 'lit'
   Queue queue;                  // variable move to front decision queue
-  double scinc;                 // current score increment
+  Links links;                  // table of links for decision queue
+  double score_inc;             // current score increment
   ScoreSchedule scores;         // score based decision priority queue
   vector<double> stab;          // table of variable scores [1,max_var]
   vector<Var> vtab;             // variable table [1,max_var]
-  Links links;                  // table of links for decision queue
+  vector<int> parents;          // parent literals during probing
   vector<Flags> ftab;           // variable and literal flags
   vector<int64_t> btab;         // enqueue time stamps for queue
   vector<int64_t> gtab;         // time stamp table to recompute glue
   vector<Occs> otab;            // table of occurrences for all literals
   vector<int> ptab;             // table for caching probing attempts
   vector<int64_t> ntab;         // number of one-sided occurrences table
-  vector<int64_t> ntab2;        // number of two-sided occurrences table
   vector<Bins> big;             // binary implication graph
   vector<Watches> wtab;         // table of watches for all literals
   Clause * conflict;            // set in 'propagation', reset in 'analyze'
@@ -197,7 +203,6 @@ struct Internal {
 #endif
   Arena arena;                  // memory arena for moving garbage collector
   Format error_message;         // provide persistent error message
-  Clause binary_subsuming;      // communicate binary subsuming clause
   string prefix;                // verbose messages prefix
 
   Internal * internal;          // proxy to 'this' in macros
@@ -205,19 +210,32 @@ struct Internal {
 
   /*----------------------------------------------------------------------*/
 
+  // Asynchronous termination flag written by 'terminate' and read by
+  // 'terminated_asynchronously' (the latter at the end of this header).
+  //
+  volatile bool termination_forced;
+
+  /*----------------------------------------------------------------------*/
+
+  const Range vars;             // Provides safe variable iteration.
+  const Sange lits;             // Provides safe literal iteration.
+
+  /*----------------------------------------------------------------------*/
+
   Internal ();
   ~Internal ();
 
   /*----------------------------------------------------------------------*/
 
   // Internal delegates and helpers for corresponding functions in
-  // 'External' and 'Solver'.  The 'init' function initializes variables up
-  // to and including the requested variable index.
+  // 'External' and 'Solver'.  The 'init_vars' function initializes
+  // variables up to and including the requested variable index.
   //
-  void init (int new_max_var);
+  void init_vars (int new_max_var);
 
   void init_enqueue (int idx);
   void init_queue (int old_max_var, int new_max_var);
+
   void init_scores (int old_max_var, int new_max_var);
 
   void add_original_lit (int lit);
@@ -266,7 +284,8 @@ struct Internal {
   //
   int vidx (int lit) const {
     int idx;
-    assert (lit), assert (lit != INT_MIN);
+    assert (lit);
+    assert (lit != INT_MIN);
     idx = abs (lit);
     assert (idx <= max_var);
     return idx;
@@ -288,31 +307,30 @@ struct Internal {
 
   // Helper functions to access variable and literal data.
   //
-  Var & var (int lit)         { return vtab[vidx (lit)]; }
-  Link & link (int lit)       { return links[vidx (lit)]; }
-  Flags & flags (int lit)     { return ftab[vidx (lit)]; }
+  Var & var (int lit)        { return vtab[vidx (lit)]; }
+  Link & link (int lit)      { return links[vidx (lit)]; }
+  Flags & flags (int lit)    { return ftab[vidx (lit)]; }
   int64_t & bumped (int lit) { return btab[vidx (lit)]; }
-  int & propfixed (int lit)   { return ptab[vlit (lit)]; }
-  double & score (int lit)    { return stab[vidx (lit)]; }
+  int & propfixed (int lit)  { return ptab[vlit (lit)]; }
+  double & score (int lit)   { return stab[vidx (lit)]; }
 
-  const Flags & flags (int lit) const { return ftab[vidx (lit)]; }
+  const Flags &
+  flags (int lit) const       { return ftab[vidx (lit)]; }
 
-  bool occurring () const { return !otab.empty (); }
-  bool watching () const { return !wtab.empty (); }
+  bool occurring () const     { return !otab.empty (); }
+  bool watching () const      { return !wtab.empty (); }
 
-  Bins & bins (int lit) { assert (!big.empty ()); return big[vlit (lit)]; }
-  Occs & occs (int lit) { assert (!otab.empty ()); return otab[vlit (lit)]; }
-  int64_t & noccs (int lit) { assert (!ntab.empty ()); return ntab[vlit (lit)]; }
-  int64_t & noccs2 (int lit) { assert (!ntab2.empty ()); return ntab2[vidx (lit)]; }
-  Watches & watches (int lit) { assert (!wtab.empty ()); return wtab[vlit (lit)]; }
+  Bins & bins (int lit)       { return big[vlit (lit)]; }
+  Occs & occs (int lit)       { return otab[vlit (lit)]; }
+  int64_t & noccs (int lit)   { return ntab[vlit (lit)]; }
+  Watches & watches (int lit) { return wtab[vlit (lit)]; }
 
-  // Variable bumping (through exponential VSIDS).
+  // Variable bumping through exponential VSIDS (EVSIDS) as in MiniSAT.
   //
   bool use_scores () const { return opts.score && stable; }
-
-  void bump_score (int lit);
-  void bump_scinc ();
-  void rescore ();
+  void bump_variable_score (int lit);
+  void bump_variable_score_inc ();
+  void rescale_variable_scores ();
 
   // Marking variables with a sign (positive or negative).
   //
@@ -443,7 +461,8 @@ struct Internal {
   // inlined here since it occurs in several inner loops.
   //
   inline void update_queue_unassigned (int idx) {
-    assert (0 < idx), assert (idx <= max_var);
+    assert (0 < idx);
+    assert (idx <= max_var);
     queue.unassigned = idx;
     queue.bumped = btab[idx];
     LOG ("queue unassigned now %d bumped %" PRId64 "", idx, btab[idx]);
@@ -549,6 +568,7 @@ struct Internal {
 
   // Lucky feasible case checking.
   //
+  int unlucky (int res);
   int trivially_false_satisfiable ();
   int trivially_true_satisfiable ();
   int forward_false_satisfiable ();
@@ -560,9 +580,14 @@ struct Internal {
 
   // Asynchronous terminating check.
   //
-  bool terminating ();                        // check 'clim', 'dlim' too
+  bool terminated_asynchronously (int factor = 1);
+
+  bool search_limits_hit ();
 
-  void terminate () { termination_forced = true; }
+  void terminate () {
+    LOG ("forcing asynchronous termination");
+    termination_forced = true;
+  }
 
   // Reducing means determining useless clauses with 'reduce' in
   // 'reduce.cpp' as well as root level satisfied clause and then removing
@@ -587,6 +612,7 @@ struct Internal {
   void flush_watches (int lit, Watches &);
   size_t flush_occs (int lit);
   void flush_all_occs_and_watches ();
+  void update_reason_references ();
   void copy_non_garbage_clauses ();
   void delete_garbage_clauses ();
   void check_clause_stats ();
@@ -599,18 +625,17 @@ struct Internal {
   void init_occs ();
   void init_bins ();
   void init_noccs ();
-  void init_watches ();
-  void clear_watches ();
   void reset_occs ();
   void reset_bins ();
   void reset_noccs ();
-  void reset_watches ();
 
   // Operators on watches.
   //
-  void sort_watches ();
+  void init_watches ();
   void connect_watches (bool irredundant_only = false);
-  void disconnect_watches ();
+  void sort_watches ();
+  void clear_watches ();
+  void reset_watches ();
 
   // Regular forward subsumption checking in 'subsume.cpp'.
   //
@@ -811,7 +836,7 @@ struct Internal {
   void elim_on_the_fly_self_subsumption (Eliminator &, Clause *, int);
   void try_to_eliminate_variable (Eliminator &, int pivot);
   void increase_elimination_bound ();
-  bool elim_round ();
+  int elim_round (bool & completed);
   void elim (bool update_limits = true);
 
   void inst_assign (int lit);
@@ -839,6 +864,8 @@ struct Internal {
   void probe_assign_decision (int lit);
   void probe_assign (int lit, int parent);
   void mark_duplicated_binary_clauses_as_garbage ();
+  int get_parent_reason_literal (int lit);
+  void set_parent_reason_literal (int lit, int reason);
   int probe_dominator (int a, int b);
   int hyper_binary_resolve (Clause*);
   void probe_propagate2 ();
@@ -885,6 +912,11 @@ struct Internal {
     return (f.assumed & bit) != 0;
   }
 
+  // Forcing decision variables to a certain phase.
+  //
+  void phase (int lit);
+  void unphase (int lit);
+
   // Globally blocked clause elimination.
   //
   bool is_autarky_literal (int lit) const;
@@ -915,6 +947,7 @@ struct Internal {
 
   // Internal functions to enable explicit search limits.
   //
+  void limit_terminate (int);
   void limit_decisions (int);           // Force decision limit.
   void limit_conflicts (int);           // Force conflict limit.
   void limit_preprocessing (int);       // Enable 'n' preprocessing rounds.
@@ -928,7 +961,9 @@ struct Internal {
   // Set all the CDCL search limits and increments for scheduling
   // inprocessing, restarts, clause database reductions, etc.
   //
-  void init_limits ();
+  void init_report_limits ();
+  void init_preprocessing_limits ();
+  void init_search_limits ();
 
   // The computed averages are local to the 'stable' and 'unstable' phase.
   // Their main use is to be reported in 'report', except for the 'glue'
@@ -944,21 +979,33 @@ struct Internal {
   // Main solve & search functions in 'internal.cpp'.
   //
   // We have three pre-solving techniques.  These consist of preprocessing,
-  // local search and searching for lucky phases, which except for the last
-  // are usually optional and then followed by the main CDCL search loop
-  // with inprocessing.  This is all orchestrated by the 'solve' function.
-  //
+  // local search and searching for lucky phases, which in full solving
+  // mode except for the last are usually optional and then followed by
+  // the main CDCL search loop with inprocessing.  If only preprocessing
+  // is requested from 'External::simplifiy' only preprocessing is called
+  // though. This is all orchestrated by the 'solve' function.
+  //
+  int already_solved ();
+  int restore_clauses ();
   bool preprocess_round (int round);
   int preprocess ();
-  //
   int local_search_round (int round);
   int local_search ();
-  //
   int lucky_phases ();
-  //
   int cdcl_loop_with_inprocessing ();
+  void reset_solving ();
+  int solve (bool preprocess_only = false);
+
+  // Perform look ahead and return the most occurring literal.
   //
-  int solve ();         // Orchestrates the three functions above.
+  int lookahead();
+  CubesWithStatus generate_cubes(int);
+  int most_occurring_literal();
+  int lookahead_probing();
+  int lookahead_next_probe();
+  void lookahead_flush_probes();
+  void lookahead_generate_probes();
+  bool terminating_asked();
 
 #ifndef QUIET
   // Built in profiling in 'profile.cpp' (see also 'profile.hpp').
@@ -977,7 +1024,9 @@ struct Internal {
   // negative.  We also avoid taking the absolute value.
   //
   signed char val (int lit) const {
-    assert (-max_var <= lit), assert (lit), assert (lit <= max_var);
+    assert (-max_var <= lit);
+    assert (lit);
+    assert (lit <= max_var);
     return vals[lit];
   }
 
@@ -986,8 +1035,11 @@ struct Internal {
   // of the variable anyhow.
   //
   int fixed (int lit) {
-    assert (-max_var <= lit), assert (lit), assert (lit <= max_var);
-    int idx = vidx (lit), res = vals[idx];
+    assert (-max_var <= lit);
+    assert (lit);
+    assert (lit <= max_var);
+    const int idx = vidx (lit);
+    int res = vals[idx];
     if (res && vtab[idx].level) res = 0;
     if (lit < 0) res = -res;
     return res;
@@ -998,7 +1050,8 @@ struct Internal {
   int externalize (int lit) {
     assert (lit != INT_MIN);
     const int idx = abs (lit);
-    assert (idx), assert (idx <= max_var);
+    assert (idx);
+    assert (idx <= max_var);
     int res = i2e[idx];
     if (lit < 0) res = -res;
     return res;
@@ -1064,8 +1117,11 @@ struct Internal {
   // Regularly reports what is going on in 'report.cpp'.
   //
   void report (char type, int verbose_level = 0);
+  void report_solving(int);
+
+  void print_statistics ();
+  void print_resource_usage ();
 
-  void print_stats ();          // Complete statistics.
 
   /*----------------------------------------------------------------------*/
 
@@ -1123,29 +1179,30 @@ struct Internal {
   void error (const char *, ...);
   void error_message_start ();
 
-  // Fatal internal error which leads to abort.
-  //
-  void fatal (const char *, ...);
-
   // Warning messages.
   //
   void warning (const char *, ...);
-
-  static void fatal_message_start ();
-  void fatal_message_end ();
 };
 
+// Fatal internal error which leads to abort.
+//
+void fatal_message_start ();
+void fatal_message_end ();
+void fatal (const char *, ...);
+
 /*------------------------------------------------------------------------*/
 
 // Has to be put here, i.e., not into 'score.hpp', since we need the
-// definition of 'Internal::score' above (after '#include "score.hpp").
+// definition of 'Internal::score' above (after '#include "score.hpp"').
 
 inline bool score_smaller::operator () (unsigned a, unsigned b) {
 
   // Avoid computing twice 'abs' in 'score ()'.
   //
-  assert (1 <= a), assert (a <= (unsigned) internal->max_var);
-  assert (1 <= b), assert (b <= (unsigned) internal->max_var);
+  assert (1 <= a);
+  assert (a <= (unsigned) internal->max_var);
+  assert (1 <= b);
+  assert (b <= (unsigned) internal->max_var);
   double s = internal->stab[a];
   double t = internal->stab[b];
 
@@ -1170,6 +1227,91 @@ inline int External::fixed (int elit) const {
   return internal->fixed (ilit);
 }
 
+/*------------------------------------------------------------------------*/
+
+// We want to have termination checks inlined, particularly the first
+// function which appears in preprocessor loops.  Even though this first
+// 'termination_forced' is set asynchronously, this should not lead to a
+// data race issue (it also has been declared 'volatile').
+
+inline bool Internal::terminated_asynchronously (int factor)
+{
+  // First way of asynchronous termination is through 'terminate' which sets
+  // the 'termination_forced' flag directly.  The second way is through a
+  // call back to a 'terminator' if it is non-zero, which however is costly.
+  //
+  if (termination_forced)
+  {
+    LOG ("termination asynchronously forced");
+    return true;
+  }
+
+  // This is only for testing and debugging asynchronous termination calls.
+  // In production code this could be removed but then should not be costly
+  // and keeping it will allow to test correctness of asynchronous
+  // termination on the production platform too.  After this triggers we
+  // have to set the 'termination_forced' flag, such that subsequent calls
+  // to this function do not check this again.
+  //
+  if (lim.terminate.forced) {
+    assert (lim.terminate.forced > 0);
+    if (lim.terminate.forced-- == 1) {
+      LOG ("internally forcing termination");
+      termination_forced = true;
+      return true;
+    }
+    LOG ("decremented internal forced termination limit to %" PRId64,
+      lim.terminate.forced);
+  }
+
+  // The second way of asynchronous termination is through registering and
+  // calling an external 'Terminator' object.  This is of course more costly
+  // than just checking a (volatile though) boolean flag, particularly in
+  // tight loops.  To avoid this cost we only call the terminator in
+  // intervals of 'opts.terminateint', which in addition can be scaled up by
+  // the argument 'factor'.  If the terminator returns 'true' we set the
+  // 'termination_forced' flag to 'true' in order to remember the
+  // termination status and to avoid the terminator again.  Setting this
+  // flag leads to the first test above to succeed in subsequent calls.
+  //
+  if (external->terminator && !lim.terminate.check--) {
+    assert (factor > 0);
+    assert (INT_MAX/factor > opts.terminateint);
+    lim.terminate.check = factor * opts.terminateint;
+    if (external->terminator->terminate ()) {
+      termination_forced = true;                        // Cache it.
+      LOG ("connected terminator forces termination");
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline bool Internal::search_limits_hit ()
+{
+  assert (!preprocessing);
+  assert (!localsearching);
+
+  if (lim.conflicts >= 0 &&
+      stats.conflicts >= lim.conflicts) {
+    LOG ("conflict limit %" PRId64 " reached", lim.conflicts);
+    return true;
+  }
+
+  if (lim.decisions >= 0 &&
+      stats.decisions >= lim.decisions) {
+    LOG ("decision limit %" PRId64 " reached", lim.decisions);
+    return true;
+  }
+
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
 }
 
 #endif
diff --git a/src/ipasir.cpp b/src/ipasir.cpp
index 67427ad9..538518d3 100644
--- a/src/ipasir.cpp
+++ b/src/ipasir.cpp
@@ -39,4 +39,11 @@ void ipasir_set_terminate (void * solver,
   ccadical_set_terminate ((CCaDiCaL *) solver, state, terminate);
 }
 
+void ipasir_set_learn (void * solver,
+                         void * state, int max_length,
+			 void (*learn)(void * state, int * clause)) {
+  ccadical_set_learn ((CCaDiCaL*) solver, state, max_length, learn);
+}
+
+
 }
diff --git a/src/ipasir.h b/src/ipasir.h
index d5e4e2b3..f54ee58e 100644
--- a/src/ipasir.h
+++ b/src/ipasir.h
@@ -25,6 +25,10 @@ int ipasir_failed (void * solver, int lit);
 void ipasir_set_terminate (void * solver,
                            void * state, int (*terminate)(void * state));
 
+void ipasir_set_learn (void * solver,
+                       void * state, int max_length,
+		       void (*learn)(void * state, int * clause));
+
 /*------------------------------------------------------------------------*/
 #ifdef __cplusplus
 }
diff --git a/src/limit.cpp b/src/limit.cpp
index 8f1a2459..97917395 100644
--- a/src/limit.cpp
+++ b/src/limit.cpp
@@ -18,39 +18,6 @@ double Internal::scale (double v) const {
 
 /*------------------------------------------------------------------------*/
 
-bool Internal::terminating () {
-
-  if (external->terminator && external->terminator->terminate ()) {
-    LOG ("connected terminator forces termination");
-    return true;
-  }
-
-  if (termination_forced) {
-    LOG ("termination forced");
-    return true;
-  }
-
-  if (!preprocessing &&
-      !localsearching &&
-      lim.conflicts >= 0 &&
-      stats.conflicts >= lim.conflicts) {
-    LOG ("conflict limit %" PRId64 " reached", lim.conflicts);
-    return true;
-  }
-
-  if (!preprocessing &&
-      !localsearching &&
-      lim.decisions >= 0 &&
-      stats.decisions >= lim.decisions) {
-    LOG ("decision limit %" PRId64 " reached", lim.decisions);
-    return true;
-  }
-
-  return false;
-}
-
-/*------------------------------------------------------------------------*/
-
 Last::Last () {
   memset (this, 0, sizeof *this);
 }
@@ -62,6 +29,18 @@ Inc::Inc () {
   decisions = conflicts = -1;           // unlimited
 }
 
+void Internal::limit_terminate (int l) {
+  if (l <= 0 && !lim.terminate.forced) {
+    LOG ("keeping unbounded terminate limit");
+  } else if (l <= 0) {
+    LOG ("reset terminate limit to be unbounded");
+    lim.terminate.forced = 0;
+  } else {
+    lim.terminate.forced = l;
+    LOG ("new terminate limit of %d calls", l);
+  }
+}
+
 void Internal::limit_conflicts (int l) {
   if (l < 0 && inc.conflicts < 0) {
     LOG ("keeping unbounded conflict limit");
@@ -111,6 +90,7 @@ void Internal::limit_local_search (int l) {
 }
 
 bool Internal::is_valid_limit (const char * name) {
+  if (!strcmp (name, "terminate")) return true;
   if (!strcmp (name, "conflicts")) return true;
   if (!strcmp (name, "decisions")) return true;
   if (!strcmp (name, "preprocessing")) return true;
@@ -120,7 +100,8 @@ bool Internal::is_valid_limit (const char * name) {
 
 bool Internal::limit (const char * name, int l) {
   bool res = true;
-       if (!strcmp (name, "conflicts")) limit_conflicts (l);
+       if (!strcmp (name, "terminate")) limit_terminate (l);
+  else if (!strcmp (name, "conflicts")) limit_conflicts (l);
   else if (!strcmp (name, "decisions")) limit_decisions (l);
   else if (!strcmp (name, "preprocessing")) limit_preprocessing (l);
   else if (!strcmp (name, "localsearch")) limit_local_search (l);
@@ -130,6 +111,7 @@ bool Internal::limit (const char * name, int l) {
 
 void Internal::reset_limits () {
   LOG ("reset limits");
+  limit_terminate (0);
   limit_conflicts (-1);
   limit_decisions (-1);
   limit_preprocessing (0);
diff --git a/src/limit.hpp b/src/limit.hpp
index af344a3c..66eef0b6 100644
--- a/src/limit.hpp
+++ b/src/limit.hpp
@@ -7,8 +7,8 @@ struct Limit {
 
   bool initialized;
 
-  int64_t conflicts;        // conflict limit if non-negative
-  int64_t decisions;        // decision limit if non-negative
+  int64_t conflicts;       // conflict limit if non-negative
+  int64_t decisions;       // decision limit if non-negative
   int64_t preprocessing;   // limit on preprocessing rounds
   int64_t localsearch;     // limit on local search rounds
 
@@ -24,8 +24,8 @@ struct Limit {
   int64_t stabilize;       // conflict limit for next 'stabilize'
   int64_t subsume;         // conflict limit for next 'subsume'
 
-  int keptsize;         // maximum kept size in 'reduce'
-  int keptglue;         // maximum kept glue in 'reduce'
+  int keptsize;            // maximum kept size in 'reduce'
+  int keptglue;            // maximum kept glue in 'reduce'
 
   // How often rephased during (1) or out (0) of stabilization.
   //
@@ -35,6 +35,11 @@ struct Limit {
   //
   int64_t elimbound;
 
+  struct {
+    int check;             // countdown to next terminator call
+    int forced;            // forced termination for testing
+  } terminate;
+
   Limit ();
 };
 
diff --git a/src/lookahead.cpp b/src/lookahead.cpp
new file mode 100644
index 00000000..0f045ff2
--- /dev/null
+++ b/src/lookahead.cpp
@@ -0,0 +1,430 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+int Internal::most_occurring_literal () {
+  init_noccs ();
+  for (const auto & c : clauses)
+    if (!c->redundant)
+      for (const auto & lit : *c)
+        if (active (lit))
+          noccs (lit)++;
+  int64_t max_noccs = 0;
+  int res = 0;
+
+  if(unsat)
+    return INT_MIN;
+
+  propagate();
+  for (int idx = 1; idx <= max_var; idx++) {
+    if (!active (idx) || assumed(idx) || assumed(-idx) || val(idx)) continue;
+    for (int sign = -1; sign <= 1; sign += 2) {
+      const int lit = sign * idx;
+      if (!active(lit))
+        continue;
+      int64_t tmp = noccs(lit);
+      if (tmp <= max_noccs)
+        continue;
+      max_noccs = tmp;
+      res = lit;
+    }
+  }
+  MSG ("maximum occurrence %" PRId64 " of literal %d", max_noccs, res);
+  reset_noccs ();
+  return res;
+}
+
+// We probe on literals first, which occur more often negated and thus we
+// sort the 'probes' stack in such a way that literals which occur negated
+// less frequently come first.  Probes are taken from the back of the stack.
+
+struct probe_negated_noccs_rank {
+  Internal * internal;
+  probe_negated_noccs_rank (Internal * i) : internal (i) { }
+  size_t operator () (int a) const { return internal->noccs (-a); }
+};
+
+
+// Follow the ideas in 'generate_probes' but flush non root probes and
+// reorder remaining probes.
+
+void Internal::lookahead_flush_probes () {
+
+  assert (!probes.empty ());
+
+  init_noccs ();
+  for (const auto & c : clauses) {
+    int a, b;
+    if (!is_binary_clause (c, a, b)) continue;
+    noccs (a)++;
+    noccs (b)++;
+  }
+
+  const auto eop = probes.end ();
+  auto j = probes.begin ();
+  for (auto i = j; i != eop; i++) {
+    int lit = *i;
+    if (!active (lit)) continue;
+    const bool have_pos_bin_occs = noccs (lit) > 0;
+    const bool have_neg_bin_occs = noccs (-lit) > 0;
+    if (have_pos_bin_occs == have_neg_bin_occs) continue;
+    if (have_pos_bin_occs) lit = -lit;
+    assert (!noccs (lit)), assert (noccs (-lit) > 0);
+    if (propfixed (lit) >= stats.all.fixed) continue;
+    LOG ("keeping probe %d negated occs %" PRId64 "", lit, noccs (-lit));
+    *j++ = lit;
+  }
+  size_t remain = j - probes.begin ();
+#ifndef QUIET
+  size_t flushed = probes.size () - remain;
+#endif
+  probes.resize (remain);
+
+  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
+
+  reset_noccs ();
+  shrink_vector (probes);
+
+  PHASE ("probe-round", stats.probingrounds,
+    "flushed %zd literals %.0f%% remaining %zd",
+    flushed, percent (flushed, remain + flushed), remain);
+}
+
+void Internal::lookahead_generate_probes () {
+
+  assert (probes.empty ());
+
+  // First determine all the literals which occur in binary clauses. It is
+  // way faster to go over the clauses once, instead of walking the watch
+  // lists for each literal.
+  //
+  init_noccs ();
+  for (const auto & c : clauses) {
+    int a, b;
+    if (!is_binary_clause (c, a, b)) continue;
+    noccs (a)++;
+    noccs (b)++;
+  }
+
+  for (int idx = 1; idx <= max_var; idx++) {
+
+    // Then focus on roots of the binary implication graph, which are
+    // literals occurring negatively in a binary clause, but not positively.
+    // If neither 'idx' nor '-idx' is a root it makes less sense to probe
+    // this variable.
+
+    // This argument requires that equivalent literal substitution through
+    // 'decompose' is performed, because otherwise there might be 'cyclic
+    // roots' which are not tried, i.e., -1 2 0, 1 -2 0, 1 2 3 0, 1 2 -3 0.
+
+    const bool have_pos_bin_occs = noccs (idx) > 0;
+    const bool have_neg_bin_occs = noccs (-idx) > 0;
+
+    // if (have_pos_bin_occs == have_neg_bin_occs) continue;
+
+    if (have_pos_bin_occs) {
+      int probe = -idx;
+
+      // See the discussion where 'propfixed' is used below.
+      //
+      if (propfixed (probe) >= stats.all.fixed) continue;
+
+      LOG ("scheduling probe %d negated occs %" PRId64 "", probe, noccs (-probe));
+      probes.push_back (probe);
+    }
+
+    if (have_neg_bin_occs) {
+      int probe = idx;
+
+      // See the discussion where 'propfixed' is used below.
+      //
+      if (propfixed (probe) >= stats.all.fixed) continue;
+
+      LOG ("scheduling probe %d negated occs %" PRId64 "",
+           probe, noccs (-probe));
+      probes.push_back (probe);
+    }
+  }
+
+  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
+
+  reset_noccs ();
+  shrink_vector (probes);
+
+  PHASE ("probe-round", stats.probingrounds,
+    "scheduled %" PRId64 " literals %.0f%%",
+    probes.size (), percent (probes.size (), 2*max_var));
+}
+
+int Internal::lookahead_next_probe () {
+
+  int generated = 0;
+
+  for (;;) {
+
+    if (probes.empty ()) {
+      if (generated++) return 0;
+      lookahead_generate_probes ();
+    }
+
+    while (!probes.empty ()) {
+
+      int probe = probes.back ();
+      probes.pop_back ();
+
+      // Eliminated or assigned.
+      //
+      if (!active (probe) || assumed(probe) || assumed (-probe)) continue;
+
+      // There is now new unit since the last time we propagated this probe,
+      // thus we propagated it before without obtaining a conflict and
+      // nothing changed since then.  Thus there is no need to propagate it
+      // again.  This observation was independently made by Partik Simons
+      // et.al. in the context of implementing 'smodels' (see for instance
+      // Alg. 4 in his JAIR article from 2002) and it has also been
+      // contributed to the thesis work of Yacine Boufkhad.
+      //
+      if (propfixed (probe) >= stats.all.fixed) continue;
+
+      return probe;
+    }
+  }
+}
+
+bool non_tautological_cube (std::vector<int> cube) {
+  std::sort(begin(cube), end(cube), clause_lit_less_than ());
+
+  for(size_t i = 0, j = 1; j < cube.size(); ++i, ++j)
+    if(cube[i] == cube[j])
+      return false;
+    else if (cube[i] == - cube[j])
+      return false;
+    else if (cube[i] == 0)
+      return false;
+
+  return true;
+
+}
+
+bool Internal::terminating_asked() {
+
+  if (external->terminator && external->terminator->terminate()) {
+    LOG("connected terminator forces termination");
+    return true;
+  }
+
+  if (termination_forced) {
+    LOG("termination forced");
+    return true;
+  }
+  return false;
+}
+
+
+// We run probing on all literals with some differences:
+//
+// * no limit on the number of propagations. We rely on terminating to stop()
+// * we run only one round
+//
+// The run can be expensive, so we actually first run the cheaper
+// occurrence version and only then run lookahead.
+//
+int Internal::lookahead_probing() {
+
+  if (!active ())
+    return 0;
+
+  LOG ("lookahead-probe-round %d without propagations limit and %d assumptions",
+       stats.probingrounds, assumptions.size());
+
+
+
+  termination_forced = false;
+
+#ifndef QUIET
+  int old_failed = stats.failed;
+  int64_t old_probed = stats.probed;
+#endif
+  int64_t old_hbrs = stats.hbrs;
+
+  if (unsat) return INT_MIN;
+  if (level) backtrack ();
+  if (!propagate ()) {
+    LOG ("empty clause before probing");
+    learn_empty_clause ();
+    return INT_MIN;
+  }
+
+  decompose ();
+
+  if (ternary ())       // If we derived a binary clause
+    decompose ();       // then start another round of ELS.
+
+  // Remove duplicated binary clauses and perform in essence hyper unary
+  // resolution, i.e., derive the unit '2' from '1 2' and '-1 2'.
+  //
+  mark_duplicated_binary_clauses_as_garbage ();
+
+  lim.conflicts = -1;
+
+  if (!probes.empty ()) lookahead_flush_probes ();
+
+  // We reset 'propfixed' since there was at least another conflict thus
+  // a new learned clause, which might produce new propagations (and hyper
+  // binary resolvents).  During 'generate_probes' we keep the old value.
+  //
+  for (int idx = 1; idx <= max_var; idx++)
+    propfixed (idx) = propfixed (-idx) = -1;
+
+  assert (unsat || propagated == trail.size ());
+  propagated = propagated2 = trail.size ();
+
+  int probe;
+  int res = most_occurring_literal();
+  int max_hbrs = -1;
+
+  set_mode (PROBE);
+
+  LOG("unsat = %d, terminating_asked () = %d ", unsat, terminating_asked ());
+  while (!unsat &&
+         !terminating_asked () &&
+         (probe = lookahead_next_probe ())) {
+    //    if (assumed(probe) || assumed(-probe))
+    //  continue;
+    stats.probed++;
+    int hbrs;
+
+    probe_assign_decision (probe);
+    if (probe_propagate ())
+      hbrs = trail.size(), backtrack();
+    else hbrs = 0, failed_literal (probe);
+    if (max_hbrs < hbrs ||
+        (max_hbrs == hbrs &&
+	 internal->bumped(probe) > internal->bumped(res))) {
+      res = probe;
+      max_hbrs = hbrs;
+    }
+  }
+
+  reset_mode (PROBE);
+
+  if (unsat) {
+    LOG ("probing derived empty clause");
+    res = INT_MIN;
+  }
+  else if (propagated < trail.size ()) {
+    LOG ("probing produced %" PRId64 " units", trail.size () - propagated);
+    if (!propagate ()) {
+      MSG ("propagating units after probing results in empty clause");
+      learn_empty_clause ();
+      res = INT_MIN;
+    } else sort_watches ();
+  }
+
+#ifndef QUIET
+  int failed = stats.failed - old_failed;
+  int64_t probed = stats.probed - old_probed;
+#endif
+  int64_t hbrs = stats.hbrs - old_hbrs;
+
+  MSG ("lookahead-probe-round %d probed %" PRId64
+       " and found %d failed literals",
+       stats.probingrounds,
+       probed, failed);
+
+  if (hbrs)
+    PHASE ("lookahead-probe-round", stats.probingrounds,
+      "found %" PRId64 " hyper binary resolvents", hbrs);
+
+  LOG ("lookahead literal %d with %d\n", res, max_hbrs);
+
+  return res;
+}
+
+CubesWithStatus Internal::generate_cubes(int depth) {
+
+  if (!active ())
+    return CubesWithStatus ();
+
+  LOG("Generating cubes of depth %i", depth);
+
+  // presimplify required due to assumptions
+
+  termination_forced = false;
+  int res = already_solved();
+  if (res == 0)
+   res = restore_clauses();
+  if(unsat)
+    res = 10;
+  if (res != 0)
+    res = solve(true);
+  if (res != 0) {
+    LOG("Solved during preprocessing");
+    CubesWithStatus cubes;
+    cubes.status = res;
+    return cubes;
+  }
+
+  reset_limits();
+  LOG ("generate cubes with %zu assumptions\n", assumptions.size());
+
+  std::vector<int> current_assumptions{assumptions};
+  std::vector<std::vector<int>> cubes {{assumptions}};
+
+  for (int i = 0; i < depth; ++i) {
+    LOG("Probing at depth %i, currently %zu have been generated",
+        i, cubes.size());
+    std::vector<std::vector<int>> cubes2 {std::move(cubes)};
+    cubes.clear ();
+
+    for (size_t j = 0; j < cubes2.size(); ++j) {
+
+      reset_assumptions();
+      for (auto lit : cubes2[j])
+        assume(lit);
+      restore_clauses();
+      propagate (), preprocess_round (0);
+      if (unsat) {
+        LOG("found unsat cube");
+        continue;
+      }
+
+      int res = lookahead_probing();
+      if(res == INT_MIN){
+        LOG ("found unsat cube");
+        continue;
+      }
+
+      LOG("splitting on lit %i", res);
+      std::vector<int> cube1{cubes2[j]};
+      cube1.push_back(res);
+      std::vector<int> cube2{std::move(cubes2[j])};
+      cube2.push_back(-res);
+      cubes.push_back(cube1);
+      cubes.push_back(cube2);
+    }
+
+    if(terminating_asked())
+      break;
+  }
+
+  assert(std::for_each(begin(cubes), end(cubes), [](std::vector<int> cube){return non_tautological_cube (cube);}));
+  reset_assumptions();
+
+  for(auto lit : current_assumptions)
+    assume(lit);
+
+  if (unsat) {
+    LOG("Solved during preprocessing");
+    CubesWithStatus cubes;
+    cubes.status = res;
+    return cubes;
+  }
+
+  CubesWithStatus rcubes;
+  rcubes.status = 0;
+  rcubes.cubes = cubes;
+  return rcubes;
+}
+
+} // namespace CaDiCaL
diff --git a/src/lucky.cpp b/src/lucky.cpp
index acbcf91b..25f34cd7 100644
--- a/src/lucky.cpp
+++ b/src/lucky.cpp
@@ -9,11 +9,28 @@ namespace CaDiCaL {
 // (forward or backward) or in the order of all clauses.  These lucky
 // assignments can be tested initially in a kind of pre-solving step.
 
+// This function factors out clean up code common among the 'lucky'
+// functions for backtracking and resetting a potential conflict.  One could
+// also use exceptions here, but there are two different reasons for
+// aborting early.  The first kind of aborting is due to asynchronous
+// termination and the second kind due to a situation in which it is clear
+// that a particular function will not be successful (for instance a
+// completely negative clause is found).  The latter situation returns zero
+// and will just abort the particular lucky function, while the former will
+// abort all (by returning '-1').
+
+int Internal::unlucky (int res) {
+  if (level > 0) backtrack ();
+  if (conflict) conflict = 0;
+  return res;
+}
+
 int Internal::trivially_false_satisfiable () {
   LOG ("checking that all clauses contain a negative literal");
   assert (!level);
   assert (assumptions.empty ());
   for (const auto & c : clauses) {
+    if (terminated_asynchronously (100)) return unlucky (-1);
     if (c->garbage) continue;
     if (c->redundant) continue;
     bool satisfied = false, found_negative_literal = false;
@@ -27,18 +44,17 @@ int Internal::trivially_false_satisfiable () {
     }
     if (satisfied || found_negative_literal) continue;
     LOG (c, "found purely positively");
-    return 0;
+    return unlucky (0);
   }
   VERBOSE (1, "all clauses contain a negative literal");
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (-idx);
     if (propagate ()) continue;
     assert (level > 0);
     LOG ("propagation failed including redundant clauses");
-    backtrack ();
-    conflict = 0;
-    return 0;
+    return unlucky (0);
   }
   stats.lucky.constant.zero++;
   return 10;
@@ -49,6 +65,7 @@ int Internal::trivially_true_satisfiable () {
   assert (!level);
   assert (assumptions.empty ());
   for (const auto & c : clauses) {
+    if (terminated_asynchronously (100)) return unlucky (-1);
     if (c->garbage) continue;
     if (c->redundant) continue;
     bool satisfied = false, found_positive_literal = false;
@@ -62,18 +79,17 @@ int Internal::trivially_true_satisfiable () {
     }
     if (satisfied || found_positive_literal) continue;
     LOG (c, "found purely negatively");
-    return 0;
+    return unlucky (0);
   }
   VERBOSE (1, "all clauses contain a positive literal");
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (idx);
     if (propagate ()) continue;
     assert (level > 0);
     LOG ("propagation failed including redundant clauses");
-    backtrack ();
-    conflict = 0;
-    return 0;
+    return unlucky (0);
   }
   stats.lucky.constant.one++;
   return 10;
@@ -86,17 +102,11 @@ int Internal::forward_false_satisfiable () {
   assert (!unsat);
   assert (!level);
   assert (assumptions.empty ());
-  int res = 0;
-  for (int idx = 1; !res && idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (terminated_asynchronously (100)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (-idx);
-    if (!propagate ()) res = 20;
-  }
-  if (res) {
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    if (!propagate ()) return unlucky (0);
   }
   VERBOSE (1, "forward assuming variables false satisfies formula");
   assert (satisfied ());
@@ -109,17 +119,11 @@ int Internal::forward_true_satisfiable () {
   assert (!unsat);
   assert (!level);
   assert (assumptions.empty ());
-  int res = 0;
-  for (int idx = 1; !res && idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (idx);
-    if (!propagate ()) res = 20;
-  }
-  if (res) {
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    if (!propagate ()) return unlucky (0);
   }
   VERBOSE (1, "forward assuming variables true satisfies formula");
   assert (satisfied ());
@@ -134,17 +138,11 @@ int Internal::backward_false_satisfiable () {
   assert (!unsat);
   assert (!level);
   assert (assumptions.empty ());
-  int res = 0;
-  for (int idx = max_var; !res && idx > 0; idx--) {
+  for (int idx = max_var; idx > 0; idx--) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (-idx);
-    if (!propagate ()) res = 20;
-  }
-  if (res) {
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    if (!propagate ()) return unlucky (0);
   }
   VERBOSE (1, "backward assuming variables false satisfies formula");
   assert (satisfied ());
@@ -157,17 +155,11 @@ int Internal::backward_true_satisfiable () {
   assert (!unsat);
   assert (!level);
   assert (assumptions.empty ());
-  int res = 0;
-  for (int idx = max_var; !res && idx > 0; idx--) {
+  for (int idx = max_var; idx > 0; idx--) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (idx);
-    if (!propagate ()) res = 20;
-  }
-  if (res) {
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    if (!propagate ()) return unlucky (0);
   }
   VERBOSE (1, "backward assuming variables true satisfies formula");
   assert (satisfied ());
@@ -188,6 +180,7 @@ int Internal::positive_horn_satisfiable () {
   assert (!level);
   assert (assumptions.empty ());
   for (const auto & c : clauses) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (c->garbage) continue;
     if (c->redundant) continue;
     int positive_literal = 0;
@@ -202,10 +195,8 @@ int Internal::positive_horn_satisfiable () {
     }
     if (satisfied) continue;
     if (!positive_literal) {
-      if (level > 0) backtrack ();
       LOG (c, "no positive unassigned literal in");
-      assert (!conflict);
-      return 0;
+      return unlucky (0);
     }
     assert (positive_literal > 0);
     LOG (c, "found positive literal %d in", positive_literal);
@@ -213,20 +204,15 @@ int Internal::positive_horn_satisfiable () {
     if (propagate ()) continue;
     LOG ("propagation of positive literal %d leads to conflict",
       positive_literal);
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    return unlucky (0);
   }
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (-idx);
     if (propagate ()) continue;
     LOG ("propagation of remaining literal %d leads to conflict", -idx);
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    return unlucky (0);
   }
   VERBOSE (1, "clauses are positive horn satisfied");
   assert (!conflict);
@@ -240,6 +226,7 @@ int Internal::negative_horn_satisfiable () {
   assert (!level);
   assert (assumptions.empty ());
   for (const auto & c : clauses) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (c->garbage) continue;
     if (c->redundant) continue;
     int negative_literal = 0;
@@ -256,8 +243,7 @@ int Internal::negative_horn_satisfiable () {
     if (!negative_literal) {
       if (level > 0) backtrack ();
       LOG (c, "no negative unassigned literal in");
-      assert (!conflict);
-      return 0;
+      return unlucky (0);
     }
     assert (negative_literal < 0);
     LOG (c, "found negative literal %d in", negative_literal);
@@ -265,20 +251,15 @@ int Internal::negative_horn_satisfiable () {
     if (propagate ()) continue;
     LOG ("propagation of negative literal %d leads to conflict",
       negative_literal);
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    return unlucky (0);
   }
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
     if (val (idx)) continue;
     search_assume_decision (idx);
     if (propagate ()) continue;
     LOG ("propagation of remaining literal %d leads to conflict", idx);
-    assert (level > 0);
-    backtrack ();
-    conflict = 0;
-    return 0;
+    return unlucky (0);
   }
   VERBOSE (1, "clauses are negative horn satisfied");
   assert (!conflict);
@@ -312,12 +293,14 @@ int Internal::lucky_phases () {
   if (!res) res = backward_true_satisfiable ();
   if (!res) res = positive_horn_satisfiable ();
   if (!res) res = negative_horn_satisfiable ();
+  if (res < 0) assert (termination_forced), res = 0;
   if (res == 10) stats.lucky.succeeded++;
   report ('l', !res);
   assert (searching_lucky_phases);
   searching_lucky_phases = false;
   STOP (lucky);
   STOP (search);
+
   return res;
 }
 
diff --git a/src/message.cpp b/src/message.cpp
index 46cb9512..651d098b 100644
--- a/src/message.cpp
+++ b/src/message.cpp
@@ -177,7 +177,7 @@ void Internal::error (const char *fmt, ...) {
 
 /*------------------------------------------------------------------------*/
 
-void Internal::fatal_message_start () {
+void fatal_message_start () {
   fflush (stdout);
   terr.bold ();
   fputs ("cadical: ", stderr);
@@ -187,13 +187,13 @@ void Internal::fatal_message_start () {
   fputc (' ', stderr);
 }
 
-void Internal::fatal_message_end () {
+void fatal_message_end () {
   fputc ('\n', stderr);
   fflush (stderr);
   abort ();
 }
 
-void Internal::fatal (const char *fmt, ...) {
+void fatal (const char *fmt, ...) {
   fatal_message_start ();
   va_list ap;
   va_start (ap, fmt);
diff --git a/src/message.hpp b/src/message.hpp
index 7aa611cd..436b59a4 100644
--- a/src/message.hpp
+++ b/src/message.hpp
@@ -7,10 +7,17 @@
 
 #ifndef QUIET
 
-#define MSG(...) internal->message (__VA_ARGS__)
-#define PHASE(...) internal->phase (__VA_ARGS__)
-#define SECTION(...) internal->section (__VA_ARGS__)
-#define VERBOSE(...) internal->verbose (__VA_ARGS__)
+#define MSG(...) \
+do { if (internal) internal->message (__VA_ARGS__); } while (0)
+
+#define PHASE(...) \
+do { if (internal) internal->phase (__VA_ARGS__); } while (0)
+
+#define SECTION(...) \
+do { if (internal) internal->section (__VA_ARGS__); } while (0)
+
+#define VERBOSE(...) \
+do { if (internal) internal->verbose (__VA_ARGS__); } while (0)
 
 #else
 
@@ -21,7 +28,7 @@
 
 #endif
 
-#define FATAL internal->fatal
+#define FATAL fatal
 #define WARNING(...) internal->warning (__VA_ARGS__)
 
 /*------------------------------------------------------------------------*/
diff --git a/src/mobical.cpp b/src/mobical.cpp
index 5e8f84ed..8cb82b3f 100644
--- a/src/mobical.cpp
+++ b/src/mobical.cpp
@@ -1,5 +1,5 @@
 /*------------------------------------------------------------------------*/
-/* Copyright (C) 2018-2019, Armin Biere, Johannes Kepler University Linz  */
+/* Copyright (C) 2018-2020, Armin Biere, Johannes Kepler University Linz  */
 /*------------------------------------------------------------------------*/
 
 // Model Based Tester for the CaDiCaL SAT Solver Library.
@@ -384,17 +384,19 @@ void Mobical::warning (const char * fmt, ...) {
 //
 //   INIT
 //   (SET|ALWAYS)*
-//   ( (ADD|ASSUME|ALWAYS)* [ (SOLVE|SIMPLIFY) (VAL|FAILED|ALWAYS ] )* )*
+//   (   (ADD|ASSUME|ALWAYS)*
+//       [ (SOLVE|SIMPLIFY|LOOKAHEAD) (VAL|FAILED|ALWAYS)* ]
+//   )*
 //   [ RESET ]
 //
 // where 'ALWAYS' calls as defined below do not change the state.  With
 // the other short-cuts below we can abstract this to
 //
-//   CONFIG* (BEFORE* [ (SOLVE|SIMPLIFY) AFTER* ] )* [ RESET ]
+//   CONFIG* (BEFORE* [ PROCESS AFTER* ] )* [ RESET ]
 //
-// If traces are read then they are checked to have this structure.  We also
-// check that 'ADD' sequences always terminate with adding a zero literal
-// before another call is made ('ASSUME | ALWAYS | SOLVE | SIMPLIFY').
+// If traces are read then they are checked to have this structure.  We
+// check that 'ADD' sequences terminate by adding zero literal before
+// another call is made ('ASSUME|ALWAYS|SOLVE|SIMPLIFY|LOOKAHEAD').
 //
 // Furthermore the execution engine (both for read and generated traces)
 // makes sure that additional contract requirements are always met.  For
@@ -417,49 +419,52 @@ struct Call {
 
     INIT        = (1<<0),
     SET         = (1<<1),
+    CONFIGURE   = (1<<2),
 
-    VARS        = (1<<2),
-    ACTIVE      = (1<<3),
-    REDUNDANT   = (1<<4),
-    IRREDUNDANT = (1<<5),
-    RESERVE     = (1<<6),
+    VARS        = (1<<3),
+    ACTIVE      = (1<<4),
+    REDUNDANT   = (1<<5),
+    IRREDUNDANT = (1<<6),
+    RESERVE     = (1<<7),
 
-    ADD         = (1<<7),
-    ASSUME      = (1<<8),
+    ADD         = (1<<8),
+    ASSUME      = (1<<9),
 
-    SOLVE       = (1<<9),
-    SIMPLIFY    = (1<<10),
+    SOLVE       = (1<<10),
+    SIMPLIFY    = (1<<11),
+    LOOKAHEAD   = (1<<12),
+    CUBING      = (1<<13),
 
-    VAL         = (1<<11),
-    FAILED      = (1<<12),
-    FIXED       = (1<<13),
+    VAL         = (1<<14),
+    FAILED      = (1<<15),
+    FIXED       = (1<<16),
 
-    FREEZE      = (1<<14),
-    FROZEN      = (1<<15),
-    MELT        = (1<<16),
+    FREEZE      = (1<<17),
+    FROZEN      = (1<<18),
+    MELT        = (1<<19),
 
-    LIMIT       = (1<<17),
-    OPTIMIZE    = (1<<18),
+    LIMIT       = (1<<20),
+    OPTIMIZE    = (1<<21),
 
-    DUMP        = (1<<19),
-    STATS       = (1<<20),
+    DUMP        = (1<<22),
+    STATS       = (1<<23),
 
-    ALWAYS      =
-      VARS | ACTIVE | REDUNDANT | IRREDUNDANT | FREEZE | FROZEN  |
-      MELT | LIMIT  | OPTIMIZE  | DUMP        | STATS  | RESERVE | FIXED,
+    RESET       = (1<<24),
 
-    CONFIG      = INIT | SET    | ALWAYS,
-    BEFORE      = ADD  | ASSUME | ALWAYS,
-    AFTER       = VAL  | FAILED | ALWAYS,
+    ALWAYS = VARS | ACTIVE | REDUNDANT | IRREDUNDANT | FREEZE | FROZEN | MELT |
+             LIMIT | OPTIMIZE | DUMP | STATS | RESERVE | FIXED,
 
-    RESET       = (1<<21)
+    CONFIG = INIT | SET | CONFIGURE | ALWAYS,
+    BEFORE = ADD | ASSUME | ALWAYS,
+    PROCESS = SOLVE | SIMPLIFY | LOOKAHEAD | CUBING,
+    AFTER = VAL | FAILED | ALWAYS,
   };
 
   Type type;            // Explicit typing.
 
   int arg;              // Argument if necessary.
   int64_t res;          // Compute result if any.
-  char * name;          // Option name for 'set'.
+  char * name;          // Option name for 'set' and 'config'
   int val;              // Option value for 'set'.
 
   Call (Type t, int a = 0, int r = 0, const char * o = 0, int v = 0) :
@@ -475,6 +480,24 @@ struct Call {
 
 /*------------------------------------------------------------------------*/
 
+static bool config_type (Call::Type t) {
+  return (((int) t & (int) Call::CONFIG)) != 0;
+}
+
+static bool before_type (Call::Type t) {
+  return (((int) t & (int) Call::BEFORE)) != 0;
+}
+
+static bool process_type (Call::Type t) {
+  return (((int) t & (int) Call::PROCESS)) != 0;
+}
+
+static bool after_type (Call::Type t) {
+  return (((int) t & (int) Call::AFTER)) != 0;
+}
+
+/*------------------------------------------------------------------------*/
+
 // The model of valid API sequences is rather implicit.  First it is encoded
 // in the random generator, by for instance adding options with 'set' only
 // right after initialization through 'init', which is also enforced during
@@ -538,6 +561,14 @@ struct SetCall : public Call {
   const char * keyword () { return "set"; }
 };
 
+struct ConfigureCall : public Call {
+  ConfigureCall (const char * o) : Call (CONFIGURE, 0, 0, o) { }
+  void execute (Solver * & s) { s->configure (name); }
+  void print (ostream & o) { o << "configure " << name << endl; }
+  Call * copy () { return new ConfigureCall (name); }
+  const char * keyword () { return "configure"; }
+};
+
 struct LimitCall : public Call {
   LimitCall (const char * o, int v) : Call (LIMIT, 0, 0, o, v) { }
   void execute (Solver * & s) { s->limit (name, val); }
@@ -589,11 +620,27 @@ struct SolveCall : public Call {
 struct SimplifyCall : public Call {
   SimplifyCall (int rounds, int r = 0) : Call (SIMPLIFY, rounds, r) { }
   void execute (Solver * & s) { res = s->simplify (arg); }
-  void print (ostream & o) { o << "solve " << arg << " " << res << endl; }
+  void print (ostream & o) { o << "simplify " << arg << " " << res << endl; }
   Call * copy () { return new SimplifyCall (arg, res); }
   const char * keyword () { return "simplify"; }
 };
 
+struct LookaheadCall : public Call {
+  LookaheadCall (int r = 0) : Call (LOOKAHEAD, 0, r) { }
+  void execute (Solver * & s) { res = s->lookahead (); }
+  void print (ostream & o) { o << "lookahead " << res << endl; }
+  Call * copy () { return new LookaheadCall (res); }
+  const char * keyword () { return "lookahead"; }
+};
+
+struct CubingCall : public Call {
+  CubingCall(int r = 1) : Call(CUBING, 0, r) {}
+  void execute(Solver *&s) { (void)s->generate_cubes(arg); }
+  void print(ostream &o) { o << "cubing " << res << endl; }
+  Call *copy() { return new CubingCall(res); }
+  const char *keyword() { return "cubing"; }
+};
+
 struct ValCall : public Call {
   ValCall (int l, int r = 0) : Call (VAL, l, r) { }
   void execute (Solver * & s) {
@@ -729,8 +776,7 @@ class Trace {
     bool first = true;
     for (size_t i = 0; i < calls.size (); i++) {
       Call * c = calls[i];
-      if (mobical.shared &&
-          (c->type == Call::SOLVE || c->type == Call::SIMPLIFY)) {
+      if (mobical.shared && process_type (c->type)) {
         mobical.shared->solved++;
         if (first) first = false;
         else mobical.shared->incremental++;
@@ -779,8 +825,7 @@ class Trace {
           c->type != Call::FAILED &&
           c->type != Call::FROZEN &&
           c->type != Call::RESET) res++, last = false;
-      if (c->type == Call::SOLVE ||
-          c->type == Call::SIMPLIFY) last = true;
+      if (process_type (c->type)) last = true;
     }
     return res;
   }
@@ -836,6 +881,7 @@ class Trace {
   void generate_reserve (Random &, int vars);
   void generate_clause (Random &, int minvars, int maxvars, int uniform);
   void generate_assume (Random &, int vars);
+  void generate_process (Random &);
   void generate_values (Random &, int vars);
   void generate_frozen (Random &, int vars);
   void generate_failed (Random &, int vars);
@@ -881,27 +927,6 @@ class Reader {
 
 /*------------------------------------------------------------------------*/
 
-static bool has_prefix (const char * str, const char * prefix) {
-  for (const char * p = str, * q = prefix; *q; p++, q++)
-    if (*p != *q)
-      return false;
-  return true;
-}
-
-static bool disabled_if_not_simplifying (const char * name) {
-  if (has_prefix (name, "block")) return true;
-  if (has_prefix (name, "compact")) return true;
-  if (has_prefix (name, "decompose")) return true;
-  if (has_prefix (name, "elim")) return true;
-  if (has_prefix (name, "inprocessing")) return true;
-  if (has_prefix (name, "probe")) return true;
-  if (has_prefix (name, "preprocessing")) return true;
-  if (has_prefix (name, "subsume")) return true;
-  if (has_prefix (name, "transred")) return true;
-  if (has_prefix (name, "vivify")) return true;
-  return false;
-}
-
 size_t Trace::first_option () {
   size_t res;
   for (res = 0; res < size (); res++)
@@ -946,6 +971,7 @@ Call * Trace::find_option_by_name (const char * name) {
 bool Trace::ignored_option (const char * name) {
 
   if (!strcmp (name, "checkfrozen")) return true;
+  if (!strcmp (name, "terminateint")) return true;
 
   return false;
 }
@@ -953,17 +979,12 @@ bool Trace::ignored_option (const char * name) {
 // Check whether the trace already contains an option which disables the
 // option 'name'.  Here we assume that an option disables another one if the
 // disabling one has as name proper prefix of the disabled one and the value
-// of the former is set to zero in the trace.  In addition we have to care
-// about all the inprocessing options, which are redundant if the 'simplify'
-// option is set to zero.
+// of the former is set to zero in the trace.
 //
 bool Trace::ignore_option (const char * name, int max_var) {
 
   if (ignored_option (name)) return true;
 
-  Call * c = find_option_by_name ("simplify");
-  if (c && !c->val && disabled_if_not_simplifying (name)) return true;
-
   // There are options which should be kept at their default value unless
   // the formula is really small.  Otherwise the solver might run 'forever'.
   //
@@ -971,7 +992,7 @@ bool Trace::ignore_option (const char * name, int max_var) {
     if (!strcmp (name, "reduce")) return true;
   }
 
-  c = find_option_by_prefix (name);
+  const Call * c = find_option_by_prefix (name);
   assert (!c || has_prefix (name, c->name));
   if (c && strlen (c->name) < strlen (name) && !c->val) return true;
 
@@ -1000,13 +1021,6 @@ void Trace::generate_options (Random & random, Size size) {
   //
   if (random.generate_double () < 0.1) return;
 
-  // With 10% probability we disable simplification.  This option needs to
-  // be put out of sorting order, otherwise the tests in 'ignore_option' to
-  // ignore useless preprocessing options will not work.
-  //
-  if (random.generate_double () < 0.1)
-    push_back (new SetCall ("simplify", 0));
-
   // In order to increase throughput we enable 'walk' in 5% tests, which
   // means disabling it in 95% of the tests.
   //
@@ -1018,15 +1032,25 @@ void Trace::generate_options (Random & random, Size size) {
   if (random.generate_double () < 0.8)
     push_back (new SetCall ("check", 1));
 
+  // In 10% of the remaining cases we use a configuration.
+  //
+  if (random.generate_double () < 0.1) {
+    const auto configs = Config::begin ();
+    const int size = Config::end () - configs;
+    const int pos = random.pick_int (0, size-1);
+    const char * config = configs[pos];
+    assert (Config::has (config));
+    push_back (new ConfigureCall (config));
+  }
+
   // This is the fraction of options changed.
   //
   double fraction = random.generate_double ();
 
   // Generate a list of options, different from default values.
   //
-  for (Options::const_iterator it = Options::begin ();
-       it != Options::end ();
-       it++) {
+  for (auto it = Options::begin (); it != Options::end (); it++)
+  {
     const Option & o = *it;
 
     // This should not be reachable unless the low and high value of an
@@ -1094,16 +1118,18 @@ void Trace::generate_reserve (Random & random, int max_var) {
 /*------------------------------------------------------------------------*/
 
 void Trace::generate_limits (Random & random) {
-  if (random.generate_double () < 0.3)
-    push_back (new LimitCall ("conflicts", random.pick_int (0, INT_MAX)));
-  if (random.generate_double () < 0.2)
-    push_back (new LimitCall ("decisions", random.pick_int (0, INT_MAX)));
+  if (random.generate_double () < 0.05)
+    push_back (new LimitCall ("terminate", random.pick_log (0, 1e5)));
+  if (random.generate_double () < 0.05)
+    push_back (new LimitCall ("conflicts", random.pick_log (0, 1e4)));
+  if (random.generate_double () < 0.05)
+    push_back (new LimitCall ("decisions", random.pick_log (0, 1e4)));
   if (random.generate_double () < 0.1)
     push_back (new LimitCall ("preprocessing", random.pick_int (0, 10)));
   if (random.generate_double () < 0.05)
     push_back (new LimitCall ("localsearch", random.pick_int (0, 1)));
   if (random.generate_double () < 0.02)
-    push_back (new OptimizeCall (random.pick_int (0, 9)));
+    push_back (new OptimizeCall (random.pick_int (0, 31)));
 }
 
 /*------------------------------------------------------------------------*/
@@ -1267,6 +1293,27 @@ void Trace::generate_freeze (Random & random, int vars) {
   }
 }
 
+void Trace::generate_process (Random & random) {
+  if (mobical.add_dump_before_solve)
+    push_back (new DumpCall ());
+
+  const double fraction = random.generate_double ();
+
+  if (fraction < 0.6) push_back(new SolveCall());
+  else if (fraction > 0.99) {
+    const int depth = random.pick_int (0, 10);
+    push_back(new CubingCall(depth));
+  }
+  else if (fraction > 0.9) push_back (new LookaheadCall ());
+  else {
+    const int rounds = random.pick_int (0, 10);
+    push_back (new SimplifyCall (rounds));
+  }
+
+  if (mobical.add_stats_after_solve)
+    push_back (new StatsCall ());
+}
+
 void Trace::generate (uint64_t i, uint64_t s) {
 
   id = i;
@@ -1333,9 +1380,7 @@ void Trace::generate (uint64_t i, uint64_t s) {
     generate_freeze (random, maxvars);
     generate_limits (random);
 
-    if (mobical.add_dump_before_solve) push_back (new DumpCall ());
-    push_back (new SolveCall ());
-    if (mobical.add_stats_after_solve) push_back (new StatsCall ());
+    generate_process (random);
 
     generate_values (random, maxvars);
     generate_failed (random, maxvars);
@@ -1659,22 +1704,10 @@ void Mobical::notify (Trace & trace, signed char ch) {
 
 /*------------------------------------------------------------------------*/
 
-static bool config_type (Call::Type t) {
-  return (((int) t & (int) Call::CONFIG)) != 0;
-}
-
-static bool before_type (Call::Type t) {
-  return (((int) t & (int) Call::BEFORE)) != 0;
-}
-
-static bool after_type (Call::Type t) {
-  return (((int) t & (int) Call::AFTER)) != 0;
-}
-
 // Explicit grammar aware three-level hierarchical delta-debugging.
 // First level is in term of incremental solving phases where one phase
 // consists of maximal prefixes of intervals of calls of type
-// '(BEFORE*|SOLVE|SIMPLIFY|AFTER*)' or single non-configuration calls.
+// '(BEFORE*|PROCESS|AFTER*)' or single non-configuration calls.
 //
 bool Trace::shrink_phases (int expected) {
   if (mobical.donot.shrink.phases) return false;
@@ -1687,9 +1720,7 @@ bool Trace::shrink_phases (int expected) {
   for (; l < size (); l = r) {
     for (r = l; r < size () && before_type (calls[r]->type); r++)
       ;
-    if (r < size () &&
-      (calls[r]->type == Call::SOLVE ||
-       calls[r]->type == Call::SIMPLIFY)) r++;
+    if (r < size () && process_type (calls[r]->type)) r++;
     for (;r < size () && after_type (calls[r]->type); r++)
       ;
     if (l < r) segments.push_back (Segment (l, r));
@@ -1741,6 +1772,8 @@ static bool is_basic (Call * c) {
     case Call::ASSUME:
     case Call::SOLVE:
     case Call::SIMPLIFY:
+    case Call::LOOKAHEAD:
+    case Call::CUBING:
     case Call::VARS:
     case Call::ACTIVE:
     case Call::REDUNDANT:
@@ -1819,7 +1852,7 @@ bool Trace::shrink_disable (int expected) {
   vector<int> lower, saved;
   for (size_t i = first_option (); i < last; i++) {
     Call * c = calls[i];
-    assert (c->type == Call::SET);
+    if (c->type != Call::SET) continue;
     if (ignore_option (c->name, max_var)) continue;
     Option * o = Options::has (c->name);
     if (!o) continue;
@@ -1892,10 +1925,11 @@ bool Trace::reduce_values (int expected) {
         if (!strcmp (c->name, "conflicts") ||
             !strcmp (c->name, "decisions"))
           lo = -1, hi = INT_MAX;
-        else if (!strcmp (c->name, "preprocessing"))
+        else if (!strcmp (c->name, "terminate") ||
+                 !strcmp (c->name, "preprocessing"))
           lo = 0, hi = INT_MAX;
         else if (!strcmp (c->name, "localsearch"))
-          lo = 0, hi = c->val;
+          lo = 0, hi = c->val; // too costly otherwise
         else continue;
       } else if (c->type == Call::OPTIMIZE) {
         lo = 0, hi = 9;
@@ -2203,6 +2237,12 @@ void Reader::parse () {
       if (!parse_int_str (second, val))
         error ("invalid second argument '%s' to 'set'", second);
       c = new SetCall (first, val);
+    } else if (!strcmp (keyword, "configure")) {
+      if (!first) error ("first argument to 'configure' missing");
+      if (enforce && !Solver::is_valid_configuration (first))
+        error ("non-existing configuration '%s'", first);
+      if (second) error ("additional argument '%s' to 'configure'", second);
+      c = new ConfigureCall (first);
     } else if (!strcmp (keyword, "limit")) {
       if (!first) error ("first argument to 'limit' missing");
       if (!second) error ("second argument to 'limit' missing");
@@ -2211,7 +2251,7 @@ void Reader::parse () {
       c = new LimitCall (first, val);
     } else if (!strcmp (keyword, "optimize")) {
       if (!first) error ("argument to 'optimize' missing");
-      if (!parse_int_str (first, val) || val < 0 || val > 9)
+      if (!parse_int_str (first, val) || val < 0 || val > 31)
         error ("invalid argument '%s' to 'optimize'", first);
       c = new OptimizeCall (val);
     } else if (!strcmp (keyword, "vars")) {
@@ -2275,6 +2315,19 @@ void Reader::parse () {
       if (second) c = new SimplifyCall (rounds, tmp);
       else        c = new SimplifyCall (rounds);
       solved++;
+    } else if (!strcmp (keyword, "lookahead")) {
+      if (first && !parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'lookahead'", first);
+      assert (!second);
+      if (first) c = new LookaheadCall (lit);
+      else       c = new LookaheadCall ();
+      solved++;
+    }  else if (!strcmp (keyword, "cubing")) {
+      if (first && !parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'cubing'", first);
+      assert (!second);
+      c = new CubingCall (lit);
+      solved++;
     } else if (!strcmp (keyword, "val")) {
       if (!first) error ("first argument to 'val' missing");
       if (!parse_int_str (first, lit))
@@ -2321,103 +2374,115 @@ void Reader::parse () {
         error ("additional argument '%s' to 'freeze'", second);
       c = new FreezeCall (lit);
     } else if (!strcmp (keyword, "melt")) {
-      if (!first) error ("argument to 'melt' missing");
-      if (!parse_int_str (first, lit))
-        error ("invalid argument '%s' to 'melt'", first);
-      if (enforce && (!lit || lit == INT_MIN))
-        error ("invalid literal '%d' as argument to 'melt'", lit);
-      if (second) error ("additional argument '%s' to 'melt'", second);
-      c = new MeltCall (lit);
-    } else if (!strcmp (keyword, "frozen")) {
-      if (!first) error ("first argument to 'frozen' missing");
-      if (!parse_int_str (first, lit))
-        error ("invalid first argument '%s' to 'frozen'", first);
-      if (second && !parse_int_str (second, val))
-        error ("invalid second argument '%s' to 'frozen'", second);
-      if (second && val != 0 && val != 1)
-        error ("invalid result argument '%d' to 'frozen'", val);
-      if (second) c = new FrozenCall (lit, val);
-      else        c = new FrozenCall (lit);
-    } else if (!strcmp (keyword, "dump")) {
-      if (first)
-        error ("additional argument '%s' to 'dump'", first);
-      c = new DumpCall ();
-    } else if (!strcmp (keyword, "stats")) {
-      if (first)
-        error ("additional argument '%s' to 'stats'", first);
-      c = new StatsCall ();
-    } else if (!strcmp (keyword, "reset")) {
-      if (first)
-        error ("additional argument '%s' to 'reset'", first);
-      c = new ResetCall ();
-    } else error ("invalid keyword '%s'", keyword);
+      if (!first) error("argument to 'melt' missing");
+    if (!parse_int_str(first, lit))
+      error("invalid argument '%s' to 'melt'", first);
+    if (enforce && (!lit || lit == INT_MIN))
+      error("invalid literal '%d' as argument to 'melt'", lit);
+    if (second)
+      error("additional argument '%s' to 'melt'", second);
+    c = new MeltCall(lit);
+  }
+  else if (!strcmp(keyword, "frozen")) {
+    if (!first)
+      error("first argument to 'frozen' missing");
+    if (!parse_int_str(first, lit))
+      error("invalid first argument '%s' to 'frozen'", first);
+    if (second && !parse_int_str(second, val))
+      error("invalid second argument '%s' to 'frozen'", second);
+    if (second && val != 0 && val != 1)
+      error("invalid result argument '%d' to 'frozen'", val);
+    if (second)
+      c = new FrozenCall(lit, val);
+    else
+      c = new FrozenCall(lit);
+  }
+  else if (!strcmp(keyword, "dump")) {
+    if (first)
+      error("additional argument '%s' to 'dump'", first);
+    c = new DumpCall();
+  }
+  else if (!strcmp(keyword, "stats")) {
+    if (first)
+      error("additional argument '%s' to 'stats'", first);
+    c = new StatsCall();
+  }
+  else if (!strcmp(keyword, "reset")) {
+    if (first)
+      error("additional argument '%s' to 'reset'", first);
+    c = new ResetCall();
+  }
+  else error("invalid keyword '%s'", keyword);
+
+  // This checks the legal structure of traces described above.
+  //
+  if (enforce) {
 
-    // This checks the legal structure of traces described above.
-    //
-    if (enforce) {
-
-      if (!state && c->type != Call::INIT)
-        error ("first call has to be an 'init' call");
-
-      if (state == Call::RESET)
-        error ("'%s' after 'reset'", c->keyword ());
-
-      if (adding && c->type != Call::ADD && c->type != Call::RESET)
-        error ("'%s' after 'add %d' without 'add 0'",
-          c->keyword (), adding);
-
-      int new_state = state;
-
-      switch (c->type) {
-
-        case Call::INIT:
-          if (state) error ("invalid second 'init' call");
-          new_state = Call::CONFIG;
-          break;
-
-        case Call::SET:
-          if (!solved && state == Call::BEFORE) {
-            assert (before_trigger);
-            error ("'set' can only be called after 'init' before '%s %d'",
-              before_trigger->keyword (), before_trigger->arg);
-          } else if (state != Call::CONFIG)
-            error ("'set' can only be called right after 'init'");
-          assert (new_state == Call::CONFIG);
-          break;
-
-        case Call::ADD:
-        case Call::ASSUME:
-          if (state != Call::BEFORE) before_trigger = c;
-          new_state = Call::BEFORE;
-          break;
-
-        case Call::VAL:
-        case Call::FAILED:
-          if (!solved && (state == Call::CONFIG || state == Call::BEFORE))
-            error ("'%s' can only be called after 'solve'", c->keyword ());
-          if (solved && state == Call::BEFORE) {
-            assert (before_trigger);
-            error ("'%s' only valid after last 'solve' and before '%s %d'",
-              c->keyword (),
-              before_trigger->keyword (), before_trigger->arg);
-          }
-          assert (state == Call::SOLVE ||
-                  state == Call::SIMPLIFY ||
-                  state == Call::AFTER);
-          new_state = Call::AFTER;
-          break;
-
-        case Call::SOLVE:
-        case Call::SIMPLIFY:
-        case Call::RESET:
-           new_state = c->type;
-           break;
-
-        default:
-          break;
+    if (!state && c->type != Call::INIT)
+      error("first call has to be an 'init' call");
+
+    if (state == Call::RESET)
+      error("'%s' after 'reset'", c->keyword());
+
+    if (adding && c->type != Call::ADD && c->type != Call::RESET)
+      error("'%s' after 'add %d' without 'add 0'", c->keyword(), adding);
+
+    int new_state = state;
+
+    switch (c->type) {
+
+    case Call::INIT:
+      if (state)
+        error("invalid second 'init' call");
+      new_state = Call::CONFIG;
+      break;
+
+    case Call::SET:
+    case Call::CONFIGURE:
+      if (!solved && state == Call::BEFORE) {
+        assert(before_trigger);
+        error("'%s' can only be called after 'init' before '%s %d'",
+              c->keyword(), before_trigger->keyword(), before_trigger->arg);
+      } else if (state != Call::CONFIG)
+        error("'%s' can only be called right after 'init'", c->keyword());
+      assert(new_state == Call::CONFIG);
+      break;
+
+    case Call::ADD:
+    case Call::ASSUME:
+      if (state != Call::BEFORE)
+        before_trigger = c;
+      new_state = Call::BEFORE;
+      break;
+
+    case Call::VAL:
+    case Call::FAILED:
+      if (!solved && (state == Call::CONFIG || state == Call::BEFORE))
+        error("'%s' can only be called after 'solve'", c->keyword());
+      if (solved && state == Call::BEFORE) {
+        assert(before_trigger);
+        error("'%s' only valid after last 'solve' and before '%s %d'",
+              c->keyword(), before_trigger->keyword(), before_trigger->arg);
       }
+      assert(state == Call::SOLVE || state == Call::SIMPLIFY ||
+             state == Call::LOOKAHEAD || state == Call::CUBING ||
+             state == Call::AFTER);
+      new_state = Call::AFTER;
+      break;
+
+    case Call::SOLVE:
+    case Call::SIMPLIFY:
+    case Call::LOOKAHEAD:
+    case Call::CUBING:
+    case Call::RESET:
+      new_state = c->type;
+      break;
+
+    default:
+      break;
+    }
 
-      state = new_state;
+    state = new_state;
     }
 
 #ifdef LOGGING
@@ -2425,14 +2490,12 @@ void Reader::parse () {
       trace.push_back (new SetCall ("log", 1));
 #endif
 
-    if (c && mobical.add_dump_before_solve &&
-        (c->type == Call::SOLVE || c->type == Call::SIMPLIFY))
+    if (c && mobical.add_dump_before_solve && process_type (c->type))
       trace.push_back (new DumpCall ());
 
     trace.push_back (c);
 
-    if (c && mobical.add_stats_after_solve &&
-        (c->type == Call::SOLVE || c->type == Call::SIMPLIFY))
+    if (c && mobical.add_stats_after_solve && process_type (c->type))
       trace.push_back (new StatsCall ());
 
     lineno++;
@@ -2722,7 +2785,7 @@ int Mobical::main (int argc, char ** argv) {
   terminal.normal ();
   prefix ();
   terminal.magenta (1);
-  fputs ("Copyright (c) 2018-2019 Armin Biere, JKU Linz\n", stderr);
+  fputs ("Copyright (c) 2018-2020 Armin Biere, JKU Linz\n", stderr);
   terminal.normal ();
   empty_line ();
   Solver::build (stderr, prefix_string ());
diff --git a/src/occs.cpp b/src/occs.cpp
index 771d8985..d7965899 100644
--- a/src/occs.cpp
+++ b/src/occs.cpp
@@ -30,7 +30,7 @@ void Internal::init_noccs () {
 }
 
 void Internal::reset_noccs () {
-  assert (!ntab.empty ());
+  assert (!max_var || !ntab.empty ());
   erase_vector (ntab);
   LOG ("reset two-sided occurrence counters");
 }
diff --git a/src/options.cpp b/src/options.cpp
index b06e3544..519f56ac 100644
--- a/src/options.cpp
+++ b/src/options.cpp
@@ -9,7 +9,7 @@ namespace CaDiCaL {
 // a static default value avoids that the stand alone solver reports that
 // '--report=1' is different from the default in 'print ()' below.
 //
-int Options::report_default_value;
+int Options::reportdefault;
 
 /*------------------------------------------------------------------------*/
 
@@ -19,13 +19,13 @@ int Options::report_default_value;
 // reinitialize this table in every call to 'Options::Options'.  This does
 // not produce a data race even for parallel initialization since the
 // same values are written by all threads under the assumption that the
-// 'report_default_value' is set before any solver is initialized.  We do
-// have to perform this static initialization though, since 'has' is
-// static and does not require that the 'Options' constructor was called.
+// 'reportdefault' is set before any solver is initialized.  We do have to
+// perform this static initialization though, since 'has' is static and does
+// not require that the 'Options' constructor was called.
 
 Option Options::table [] = {
-#define OPTION(N,V,L,H,O,D) \
-  { #N, (int) V, (int) L, (int) H, (int) O, D },
+#define OPTION(N,V,L,H,O,P,R,D) \
+  { #N, (int) V, (int) L, (int) H, (int) O, (bool) P, D },
   OPTIONS
 #undef OPTION
 };
@@ -50,56 +50,6 @@ Option * Options::has (const char * name) {
 
 /*------------------------------------------------------------------------*/
 
-bool Options::parse_option_value (const char * val_str, int & val) {
-  if (!strcmp (val_str, "true")) val = 1;
-  else if (!strcmp (val_str, "false")) val = 0;
-  else {
-    const char * p = val_str;
-    int sign;
-
-    if (*p == '-') sign = -1, p++;
-    else sign = 1;
-
-    int ch;
-    if (!isdigit ((ch = *p++))) return false;
-
-    const int64_t bound = - (int64_t) INT_MIN;
-    int64_t mantissa = ch - '0';
-
-    while (isdigit (ch = *p++)) {
-      if (bound / 10 < mantissa) mantissa = bound;
-      else mantissa *= 10;
-      const int digit = ch - '0';
-      if (bound - digit < mantissa) mantissa = bound;
-      else mantissa += digit;
-    }
-
-    int exponent = 0;
-    if (ch  == 'e') {
-      while (isdigit ((ch = *p++)))
-        exponent = exponent ? 10 : ch - '0';
-      if (ch) return false;
-    } else if (ch) return false;
-
-    assert (exponent <= 10);
-    int64_t val64 = mantissa;
-    for (int i = 0; i < exponent; i++) val64 *= 10;
-
-    if (sign < 0) {
-      val64 = -val64;
-      if (val64 < INT_MIN) val64 = INT_MIN;
-    } else {
-      if (val64 > INT_MAX) val64 = INT_MAX;
-    }
-
-    assert (INT_MIN <= val64);
-    assert (val64 <= INT_MAX);
-
-    val = val64;
-  }
-  return true;
-}
-
 bool Options::parse_long_option (const char * arg,
                                  string & name, int & val) {
   if (arg[0] != '-' || arg[1] != '-') return false;
@@ -113,7 +63,7 @@ bool Options::parse_long_option (const char * arg,
   if (pos == string::npos) val = !has_no_prefix;
   else {
     const char * val_str = name.c_str () + pos + 1;
-    if (!parse_option_value (val_str, val)) return false;
+    if (!parse_int_str (val_str, val)) return false;
   }
   return true;
 }
@@ -134,7 +84,7 @@ void Options::initialize_from_environment (
   *q = 0;
   const char * val_str = getenv (key);
   if (!val_str) return;
-  if (!parse_option_value (val_str, val)) return;
+  if (!parse_int_str (val_str, val)) return;
   if (val < L) val = L;
   if (val > H) val = H;
 }
@@ -149,7 +99,7 @@ Options::Options (Internal * s) : internal (s)
   //
   const char * prev = "";
   size_t i = 0;
-# define OPTION(N,V,L,H,O,D) \
+# define OPTION(N,V,L,H,O,P,R,D) \
   do { \
     if ((L) > (V)) \
       FATAL ("'" #N "' default '" #V "' " \
@@ -166,7 +116,7 @@ Options::Options (Internal * s) : internal (s)
     /* Thus this construction just reinitializes the table too even */ \
     /* though it might not be necessary. */ \
     assert (!table[i].name || !strcmp (table[i].name, #N)); \
-    table[i] = { #N, (int)(V), (int)(L), (int)(H), (int)(O), D }; \
+    table[i] = { #N, (int)(V), (int)(L), (int)(H), (int)(O), (bool)(P), D }; \
     prev = #N; \
     i++; \
   } while (0);
@@ -184,7 +134,7 @@ Options::Options (Internal * s) : internal (s)
 
   // Now overwrite default options with environment values.
   //
-# define OPTION(N,V,L,H,O,D) \
+# define OPTION(N,V,L,H,O,P,R,D) \
   initialize_from_environment (N, #N, L, H);
   OPTIONS
 # undef OPTION
@@ -237,7 +187,7 @@ void Options::print () {
 #endif
   char buffer[160];
   // We prefer the macro iteration here since '[VLH]' might be '1e9' etc.
-#define OPTION(N,V,L,H,O,D) \
+#define OPTION(N,V,L,H,O,P,R,D) \
   if (N != (V)) different++; \
   if (verbose || N != (V)) { \
     if ((L) == 0 && (H) == 1) { \
@@ -270,7 +220,7 @@ void Options::print () {
 
 void Options::usage () {
   // We prefer the macro iteration here since '[VLH]' might be '1e9' etc.
-#define OPTION(N,V,L,H,O,D) \
+#define OPTION(N,V,L,H,O,P,R,D) \
   if ((L) == 0 && (H) == 1) \
     printf ("  %-26s " D " [%s]\n", \
       "--" #N "=bool", (bool)(V) ? "true" : "false"); \
@@ -305,7 +255,7 @@ void Options::optimize (int val) {
     factor10 *= 10;
 
   unsigned increased = 0;
-#define OPTION(N,V,L,H,O,D) \
+#define OPTION(N,V,L,H,O,P,R,D) \
   do { \
     if (!(O)) break; \
     const int64_t factor = ((O) == 1 ? factor2 : factor10); \
@@ -327,4 +277,60 @@ void Options::optimize (int val) {
 
 /*------------------------------------------------------------------------*/
 
+void Options::disable_preprocessing () {
+  size_t count = 0;
+#define OPTION(N,V,L,H,O,P,R,D) \
+  do { \
+    if (!(P)) break; \
+    if (!(N)) break; \
+    assert ((L) == 0); \
+    assert ((H) == 1); \
+    LOG ("plain mode disables '%s'", #N); \
+    count++; \
+    N = 0; \
+  } while (0);
+  OPTIONS
+#undef OPTION
+  LOG ("forced plain mode disabled %zd preprocessing options", count);
+}
+
+bool Options::is_preprocessing_option (const char * name) {
+  Option * o = has (name);
+  return o ? o->preprocessing : false;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::reset_default_values () {
+  size_t count = 0;
+#define OPTION(N,V,L,H,O,P,R,D) \
+  do { \
+    if (!(R)) break; \
+    if (N == (V)) break; \
+    LOG ("resetting option '%s' to default %s", #N, #V); \
+    count++; \
+    N = (int)(V); \
+  } while (0);
+  OPTIONS
+#undef OPTION
+  LOG ("reset %zd options to their default values", count);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::copy (Options & other) const {
+#ifdef LOGGING
+  Internal * internal = other.internal;
+#endif
+#define OPTION(N,V,L,H,O,P,R,D) \
+  if ((N) == (int)(V)) \
+    LOG ("keeping non default option '--%s=%s'", #N, #V); \
+  else if ((N) != (int)(V)) { \
+    LOG ("overwriting default option by '--%s=%d'", #N, N); \
+    other.N = N; \
+  }
+  OPTIONS
+#undef OPTION
+}
+
 }
diff --git a/src/options.hpp b/src/options.hpp
index 200010d9..98810d76 100644
--- a/src/options.hpp
+++ b/src/options.hpp
@@ -8,179 +8,180 @@
 // initializing the options will trigger an internal error.  For the model
 // based tester 'mobical' the policy is that options which become redundant
 // because another one is disabled (set to zero) should have the name of the
-// latter as prefix.  In addition, one explicitly has to tell 'mobical' if
-// an option becomes disabled if 'simplify' is set to zero.  The 'O' column
-// determines the options which are target to 'optimize' them ('-O[1-3]').
-// A zero value in the 'O' column means that this option is not optimized.
-// A value of '1' results in optimizing its value exponentially with
-// exponent base '2', and a value of '2' uses base '10'.
+// latter as prefix.  The 'O' column determines the options which are
+// target to 'optimize' them ('-O[1-3]').  A zero value in the 'O' column
+// means that this option is not optimized.  A value of '1' results in
+// optimizing its value exponentially with exponent base '2', and a value
+// of '2' uses base '10'.  The 'P' column determines simplification
+// options (disabled with '--plain') and 'R' which values can be reset.
 
 #define OPTIONS \
 \
-/*      NAME         DEFAULT, LO, HI, O, USAGE */ \
+/*      NAME         DEFAULT, LO, HI,O,P,R, USAGE */ \
 \
-OPTION( arena,             1,  0,  1, 0, "allocate clauses in arena") \
-OPTION( arenacompact,      1,  0,  1, 0, "keep clauses compact") \
-OPTION( arenasort,         1,  0,  1, 0, "sort clauses in arena") \
-OPTION( arenatype,         3,  1,  3, 0, "1=clause, 2=var, 3=queue") \
-OPTION( binary,            1,  0,  1, 0, "use binary proof format") \
-OPTION( block,             0,  0,  1, 0, "blocked clause elimination") \
-OPTION( blockmaxclslim,  1e5,  1,2e9, 2, "maximum clause size") \
-OPTION( blockminclslim,    4,  2,2e9, 0, "minimum clause size") \
-OPTION( blockocclim,     1e2,  1,2e9, 2, "occurrence limit") \
-OPTION( bump,              1,  0,  1, 0, "bump variables") \
-OPTION( bumpreason,        1,  0,  1, 0, "bump reason literals too") \
-OPTION( bumpreasondepth,   1,  1,  3, 0, "bump reason depth") \
-OPTION( check,             0,  0,  1, 0, "enable internal checking") \
-OPTION( checkassumptions,  1,  0,  1, 0, "check assumptions satisfied") \
-OPTION( checkfailed,       1,  0,  1, 0, "check failed literals form core") \
-OPTION( checkfrozen,       0,  0,  1, 0, "check all frozen semantics") \
-OPTION( checkproof,        1,  0,  1, 0, "check proof internally") \
-OPTION( checkwitness,      1,  0,  1, 0, "check witness internally") \
-OPTION( chrono,            1,  0,  2, 0, "chronological backtracking") \
-OPTION( chronoalways,      0,  0,  1, 0, "force always chronological") \
-OPTION( chronolevelim,   1e2,  0,2e9, 0, "chronological level limit") \
-OPTION( chronoreusetrail,  1,  0,  1, 0, "reuse trail chronologically") \
-OPTION( compact,           1,  0,  1, 0, "compact internal variables") \
-OPTION( compactint,      2e3,  1,2e9, 0, "compacting interval") \
-OPTION( compactlim,      1e2,  0,1e3, 0, "inactive limit in per mille") \
-OPTION( compactmin,      1e2,  1,2e9, 0, "minimum inactive limit") \
-OPTION( condition,         0,  0,  1, 0, "globally blocked clause elim") \
-OPTION( conditionint,    1e4,  1,2e9, 0, "initial conflict interval") \
-OPTION( conditionmaxeff, 1e7,  0,2e9, 1, "maximum condition efficiency") \
-OPTION( conditionmaxratio,100, 1,2e9, 1, "maximum clause variable ratio") \
-OPTION( conditionmineff, 1e6,  0,2e9, 1, "minimum condition efficiency") \
-OPTION( conditionreleff, 100,  1,1e5, 0, "relative efficiency in per mille") \
-OPTION( cover,             0,  0,  1, 0, "covered clause elimination") \
-OPTION( covermaxclslim,  1e5,  1,2e9, 2, "maximum clause size") \
-OPTION( covermaxeff,     1e8,  0,2e9, 1, "maximum cover efficiency") \
-OPTION( coverminclslim,    4,  2,2e9, 0, "minimum clause size") \
-OPTION( covermineff,     1e6,  0,2e9, 1, "minimum cover efficiency") \
-OPTION( coverreleff,       4,  1,1e5, 1, "relative efficiency per mille") \
-OPTION( decompose,         1,  0,  1, 0, "decompose BIG in SCCs and ELS") \
-OPTION( decomposerounds,   2,  1, 16, 1, "number of decompose rounds") \
-OPTION( deduplicate,       1,  0,  1, 0, "remove duplicated binary clauses") \
-OPTION( eagersubsume,      1,  0,  1, 0, "subsume eagerly recently learned") \
-OPTION( eagersubsumelim,  20,  1,1e3, 0, "limit on subsumed candidates") \
-OPTION( elim,              1,  0,  1, 0, "bounded variable elimination") \
-OPTION( elimands,          1,  0,  1, 0, "find AND gates") \
-OPTION( elimaxeff,       2e9,  0,2e9, 1, "maximum elimination efficiency") \
-OPTION( elimbackward,      1,  0,  1, 0, "eager backward subsumption") \
-OPTION( elimboundmax,     16, -1,2e6, 1, "maximum elimination bound") \
-OPTION( elimboundmin,      0, -1,2e6, 0, "minimum elimination bound") \
-OPTION( elimclslim,      1e2,  2,2e9, 2, "resolvent size limit") \
-OPTION( elimequivs,        1,  0,  1, 0, "find equivalence gates") \
-OPTION( elimineff,       1e7,  0,2e9, 1, "minimum elimination efficiency") \
-OPTION( elimint,         2e3,  1,2e9, 0, "elimination interval") \
-OPTION( elimites,          1,  0,  1, 0, "find if-then-else gates") \
-OPTION( elimlimited,       1,  0,  1, 0, "limit resolutions") \
-OPTION( elimocclim,      1e3,  0,2e9, 2, "occurrence limit") \
-OPTION( elimprod,          1,  0,1e4, 0, "elimination score product") \
-OPTION( elimreleff,      1e3,  1,1e5, 1, "relative efficiency per mille") \
-OPTION( elimrounds,        2,  1,512, 1, "usual number of rounds") \
-OPTION( elimsubst,         1,  0,  1, 0, "elimination by substitution") \
-OPTION( elimxorlim,        5,  2, 27, 1, "maximum XOR size") \
-OPTION( elimxors,          1,  0,  1, 0, "find XOR gates") \
-OPTION( emagluefast,      33,  1,2e9, 0, "window fast glue") \
-OPTION( emaglueslow,     1e5,  1,2e9, 0, "window slow glue") \
-OPTION( emajump,         1e5,  1,2e9, 0, "window back-jump level") \
-OPTION( emalevel,        1e5,  1,2e9, 0, "window back-track level") \
-OPTION( emasize,         1e5,  1,2e9, 0, "window learned clause size") \
-OPTION( ematrailfast,    1e2,  1,2e9, 0, "window fast trail") \
-OPTION( ematrailslow,    1e5,  1,2e9, 0, "window slow trail") \
-OPTION( flush,             0,  0,  1, 0, "flush redundant clauses") \
-OPTION( flushfactor,       3,  1,1e3, 0, "interval increase") \
-OPTION( flushint,        1e5,  1,2e9, 0, "initial limit") \
-OPTION( forcephase,        0,  0,  1, 0, "always use initial phase") \
-OPTION( inprocessing,      1,  0,  1, 0, "enable inprocessing") \
-OPTION( instantiate,       0,  0,  1, 0, "variable instantiation") \
-OPTION( instantiateclslim, 3,  2,2e9, 0, "minimum clause size") \
-OPTION( instantiateocclim, 1,  1,2e9, 2, "maximum occurrence limit") \
-OPTION( instantiateonce,   1,  0,  1, 0, "instantiate each clause once") \
-LOGOPT( log,               0,  0,  1, 0, "enable logging") \
-LOGOPT( logsort,           0,  0,  1, 0, "sort logged clauses") \
-OPTION( lucky,             1,  0,  1, 0, "search for lucky phases") \
-OPTION( minimize,          1,  0,  1, 0, "minimize learned clauses") \
-OPTION( minimizedepth,   1e3,  0,1e3, 0, "minimization depth") \
-OPTION( phase,             1,  0,  1, 0, "initial phase") \
-OPTION( probe,             1,  0,  1, 0, "failed literal probing" ) \
-OPTION( probehbr,          1,  0,  1, 0, "learn hyper binary clauses") \
-OPTION( probeint,        5e3,  1,2e9, 0, "probing interval" ) \
-OPTION( probemaxeff,     1e8,  0,2e9, 1, "maximum probing efficiency") \
-OPTION( probemineff,     1e6,  0,2e9, 1, "minimum probing efficiency") \
-OPTION( probereleff,      20,  1,1e5, 1, "relative efficiency per mille") \
-OPTION( proberounds,       1,  1, 16, 1, "probing rounds" ) \
-OPTION( profile,           2,  0,  4, 0, "profiling level") \
-QUTOPT( quiet,             0,  0,  1, 0, "disable all messages") \
-OPTION( radixsortlim,    800,  0,2e9, 0, "radix sort limit") \
-OPTION( realtime,          0,  0,  1, 0, "real instead of process time") \
-OPTION( reduce,            1,  0,  1, 0, "reduce useless clauses") \
-OPTION( reduceint,       300, 10,1e6, 0, "reduce interval") \
-OPTION( reducetarget,     75, 10,1e2, 0, "reduce fraction in percent") \
-OPTION( reducetier1glue,   2,  1,2e9, 0, "glue of kept learned clauses") \
-OPTION( reducetier2glue,   6,  1,2e9, 0, "glue of tier two clauses") \
-OPTION( reluctant,      1024,  0,2e9, 0, "reluctant doubling period") \
-OPTION( reluctantmax,1048576,  0,2e9, 0, "reluctant doubling period") \
-OPTION( rephase,           1,  0,  1, 0, "enable resetting phase") \
-OPTION( rephaseint,      1e3,  1,2e9, 0, "rephase interval") \
-OPTION( report,report_default_value,  0,  1, 0, "enable reporting") \
-OPTION( reportall,         0,  0,  1, 0, "report even if not successful") \
-OPTION( reportsolve,       0,  0,  1, 0, "use solving not process time") \
-OPTION( restart,           1,  0,  1, 0, "enable restarts") \
-OPTION( restartint,        2,  1,2e9, 0, "restart interval") \
-OPTION( restartmargin,    10,  0,1e2, 0, "slow fast margin in percent") \
-OPTION( restartreusetrail, 1,  0,  1, 0, "enable trail reuse") \
-OPTION( restoreall,        0,  0,  2, 0, "restore all clauses (2=really)") \
-OPTION( restoreflush,      0,  0,  1, 0, "remove satisfied clauses") \
-OPTION( reverse,           0,  0,  1, 0, "reverse variable ordering") \
-OPTION( score,             1,  0,  1, 0, "use EVSIDS scores") \
-OPTION( scorefactor,     950,500,1e3, 0, "score factor per mille") \
-OPTION( seed,              0,  0,2e9, 0, "random seed") \
-OPTION( shuffle,           0,  0,  1, 0, "shuffle variables") \
-OPTION( shufflequeue,      1,  0,  1, 0, "shuffle variable queue") \
-OPTION( shufflerandom,     0,  0,  1, 0, "not reverse but random") \
-OPTION( shufflescores,     1,  0,  1, 0, "shuffle variable scores") \
-OPTION( simplify,          1,  0,  1, 0, "enable simplifier") \
-OPTION( stabilize,         1,  0,  1, 0, "enable stabilizing phases") \
-OPTION( stabilizefactor, 200,101,2e9, 0, "phase increase in percent") \
-OPTION( stabilizeint,    1e3,  1,2e9, 0, "stabilizing interval") \
-OPTION( stabilizemaxint, 2e9,  1,2e9, 0, "maximum stabilizing phase") \
-OPTION( stabilizeonly,     0,  0,  1, 0, "only stabilizing phases") \
-OPTION( stabilizephase,    1,  0,  1, 0, "use target variable phase") \
-OPTION( subsume,           1,  0,  1, 0, "enable clause subsumption") \
-OPTION( subsumebinlim,   1e4,  0,2e9, 1, "watch list length limit") \
-OPTION( subsumeclslim,   1e3,  0,2e9, 2, "clause length limit") \
-OPTION( subsumeint,      1e4,  1,2e9, 0, "subsume interval") \
-OPTION( subsumelimited,    1,  0,  1, 0, "limit subsumption checks") \
-OPTION( subsumemaxeff,   1e8,  0,2e9, 1, "maximum subsuming efficiency") \
-OPTION( subsumemineff,   1e6,  0,2e9, 1, "minimum subsuming efficiency") \
-OPTION( subsumeocclim,   1e2,  0,2e9, 1, "watch list length limit") \
-OPTION( subsumereleff,   1e3,  1,1e5, 1, "relative efficiency per mille") \
-OPTION( subsumestr,        1,  0,  1, 0, "strengthen during subsume") \
-OPTION( ternary,           1,  0,  1, 0, "hyper ternary resolution") \
-OPTION( ternarymaxadd,   1e3,  0,1e4, 1, "maximum clauses added in percent") \
-OPTION( ternarymaxeff,   1e8,  0,2e9, 1, "ternary maximum efficiency") \
-OPTION( ternarymineff,   1e6,  1,2e9, 1, "minimum ternary efficiency") \
-OPTION( ternaryocclim,   1e2,  1,2e9, 2, "ternary occurrence limit") \
-OPTION( ternaryreleff,    10,  1,1e5, 1, "relative efficiency in per mille") \
-OPTION( ternaryrounds,     2,  1, 16, 1, "maximum ternary rounds") \
-OPTION( transred,          1,  0,  1, 0, "transitive reduction of BIG") \
-OPTION( transredmaxeff,  1e8,  0,2e9, 1, "maximum efficiency") \
-OPTION( transredmineff,  1e6,  0,2e9, 1, "minimum efficiency") \
-OPTION( transredreleff,  1e2,  1,1e5, 1, "relative efficiency per mille") \
-QUTOPT( verbose,           0,  0,  3, 0, "more verbose messages") \
-OPTION( vivify,            1,  0,  1, 0, "vivification") \
-OPTION( vivifymaxeff,    1e8,  0,2e9, 1, "maximum efficiency") \
-OPTION( vivifymineff,    1e5,  0,2e9, 1, "minimum efficiency") \
-OPTION( vivifyonce,        0,  0,  2, 0, "vivify once: 1=red, 2=red+irr") \
-OPTION( vivifyredeff,    300,  0,1e3, 1, "redundant efficiency per mille") \
-OPTION( vivifyreleff,     80,  1,1e5, 1, "relative efficiency per mille") \
-OPTION( walk,              1,  0,  1, 0, "enable random walks") \
-OPTION( walkmaxeff,      1e7,  0,2e9, 1, "maximum efficiency") \
-OPTION( walkmineff,      1e5,  0,1e7, 1, "minimum efficiency") \
-OPTION( walknonstable,     1,  0,  1, 0, "walk in non-stabilizing phase") \
-OPTION( walkredundant,     0,  0,  1, 0, "walk redundant clauses too") \
-OPTION( walkreleff,       20,  1,1e5, 1, "relative efficiency per mille") \
+OPTION( arena,             1,  0,  1,0,0,1, "allocate clauses in arena") \
+OPTION( arenacompact,      1,  0,  1,0,0,1, "keep clauses compact") \
+OPTION( arenasort,         1,  0,  1,0,0,1, "sort clauses in arena") \
+OPTION( arenatype,         3,  1,  3,0,0,1, "1=clause, 2=var, 3=queue") \
+OPTION( binary,            1,  0,  1,0,0,1, "use binary proof format") \
+OPTION( block,             0,  0,  1,0,1,1, "blocked clause elimination") \
+OPTION( blockmaxclslim,  1e5,  1,2e9,2,0,1, "maximum clause size") \
+OPTION( blockminclslim,    2,  2,2e9,0,0,1, "minimum clause size") \
+OPTION( blockocclim,     1e2,  1,2e9,2,0,1, "occurrence limit") \
+OPTION( bump,              1,  0,  1,0,0,1, "bump variables") \
+OPTION( bumpreason,        1,  0,  1,0,0,1, "bump reason literals too") \
+OPTION( bumpreasondepth,   1,  1,  3,0,0,1, "bump reason depth") \
+OPTION( check,             0,  0,  1,0,0,0, "enable internal checking") \
+OPTION( checkassumptions,  1,  0,  1,0,0,0, "check assumptions satisfied") \
+OPTION( checkfailed,       1,  0,  1,0,0,0, "check failed literals form core") \
+OPTION( checkfrozen,       0,  0,  1,0,0,0, "check all frozen semantics") \
+OPTION( checkproof,        1,  0,  1,0,0,0, "check proof internally") \
+OPTION( checkwitness,      1,  0,  1,0,0,0, "check witness internally") \
+OPTION( chrono,            1,  0,  2,0,0,1, "chronological backtracking") \
+OPTION( chronoalways,      0,  0,  1,0,0,1, "force always chronological") \
+OPTION( chronolevelim,   1e2,  0,2e9,0,0,1, "chronological level limit") \
+OPTION( chronoreusetrail,  1,  0,  1,0,0,1, "reuse trail chronologically") \
+OPTION( compact,           1,  0,  1,0,1,1, "compact internal variables") \
+OPTION( compactint,      2e3,  1,2e9,0,0,1, "compacting interval") \
+OPTION( compactlim,      1e2,  0,1e3,0,0,1, "inactive limit per mille") \
+OPTION( compactmin,      1e2,  1,2e9,0,0,1, "minimum inactive limit") \
+OPTION( condition,         0,  0,  1,0,0,1, "globally blocked clause elim") \
+OPTION( conditionint,    1e4,  1,2e9,0,0,1, "initial conflict interval") \
+OPTION( conditionmaxeff, 1e7,  0,2e9,1,0,1, "maximum condition efficiency") \
+OPTION( conditionmaxrat, 100,  1,2e9,1,0,1, "maximum clause variable ratio") \
+OPTION( conditionmineff, 1e6,  0,2e9,1,0,1, "minimum condition efficiency") \
+OPTION( conditionreleff, 100,  1,1e5,0,0,1, "relative efficiency per mille") \
+OPTION( cover,             0,  0,  1,0,1,1, "covered clause elimination") \
+OPTION( covermaxclslim,  1e5,  1,2e9,2,0,1, "maximum clause size") \
+OPTION( covermaxeff,     1e8,  0,2e9,1,0,1, "maximum cover efficiency") \
+OPTION( coverminclslim,    2,  2,2e9,0,0,1, "minimum clause size") \
+OPTION( covermineff,     1e6,  0,2e9,1,0,1, "minimum cover efficiency") \
+OPTION( coverreleff,       4,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( decompose,         1,  0,  1,0,1,1, "decompose BIG in SCCs and ELS") \
+OPTION( decomposerounds,   2,  1, 16,1,0,1, "number of decompose rounds") \
+OPTION( deduplicate,       1,  0,  1,0,1,1, "remove duplicated binaries") \
+OPTION( eagersubsume,      1,  0,  1,0,0,1, "subsume recently learned") \
+OPTION( eagersubsumelim,  20,  1,1e3,0,0,1, "limit on subsumed candidates") \
+OPTION( elim,              1,  0,  1,0,1,1, "bounded variable elimination") \
+OPTION( elimands,          1,  0,  1,0,0,1, "find AND gates") \
+OPTION( elimaxeff,       2e9,  0,2e9,1,0,1, "maximum elimination efficiency") \
+OPTION( elimbackward,      1,  0,  1,0,0,1, "eager backward subsumption") \
+OPTION( elimboundmax,     16, -1,2e6,1,0,1, "maximum elimination bound") \
+OPTION( elimboundmin,      0, -1,2e6,0,0,1, "minimum elimination bound") \
+OPTION( elimclslim,      1e2,  2,2e9,2,0,1, "resolvent size limit") \
+OPTION( elimequivs,        1,  0,  1,0,0,1, "find equivalence gates") \
+OPTION( elimineff,       1e7,  0,2e9,1,0,1, "minimum elimination efficiency") \
+OPTION( elimint,         2e3,  1,2e9,0,0,1, "elimination interval") \
+OPTION( elimites,          1,  0,  1,0,0,1, "find if-then-else gates") \
+OPTION( elimlimited,       1,  0,  1,0,0,1, "limit resolutions") \
+OPTION( elimocclim,      1e2,  0,2e9,2,0,1, "occurrence limit") \
+OPTION( elimprod,          1,  0,1e4,0,0,1, "elim score product weight") \
+OPTION( elimreleff,      1e3,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( elimrounds,        2,  1,512,1,0,1, "usual number of rounds") \
+OPTION( elimsubst,         1,  0,  1,0,0,1, "elimination by substitution") \
+OPTION( elimsum,           1,  0,1e4,0,0,1, "elimination score sum weight") \
+OPTION( elimxorlim,        5,  2, 27,1,0,1, "maximum XOR size") \
+OPTION( elimxors,          1,  0,  1,0,0,1, "find XOR gates") \
+OPTION( emagluefast,      33,  1,2e9,0,0,1, "window fast glue") \
+OPTION( emaglueslow,     1e5,  1,2e9,0,0,1, "window slow glue") \
+OPTION( emajump,         1e5,  1,2e9,0,0,1, "window back-jump level") \
+OPTION( emalevel,        1e5,  1,2e9,0,0,1, "window back-track level") \
+OPTION( emasize,         1e5,  1,2e9,0,0,1, "window learned clause size") \
+OPTION( ematrailfast,    1e2,  1,2e9,0,0,1, "window fast trail") \
+OPTION( ematrailslow,    1e5,  1,2e9,0,0,1, "window slow trail") \
+OPTION( flush,             0,  0,  1,0,0,1, "flush redundant clauses") \
+OPTION( flushfactor,       3,  1,1e3,0,0,1, "interval increase") \
+OPTION( flushint,        1e5,  1,2e9,0,0,1, "initial limit") \
+OPTION( forcephase,        0,  0,  1,0,0,1, "always use initial phase") \
+OPTION( inprocessing,      1,  0,  1,0,0,1, "enable inprocessing") \
+OPTION( instantiate,       0,  0,  1,0,1,1, "variable instantiation") \
+OPTION( instantiateclslim, 3,  2,2e9,0,0,1, "minimum clause size") \
+OPTION( instantiateocclim, 1,  1,2e9,2,0,1, "maximum occurrence limit") \
+OPTION( instantiateonce,   1,  0,  1,0,0,1, "instantiate each clause once") \
+LOGOPT( log,               0,  0,  1,0,0,0, "enable logging") \
+LOGOPT( logsort,           0,  0,  1,0,0,0, "sort logged clauses") \
+OPTION( lucky,             1,  0,  1,0,0,1, "search for lucky phases") \
+OPTION( minimize,          1,  0,  1,0,0,1, "minimize learned clauses") \
+OPTION( minimizedepth,   1e3,  0,1e3,0,0,1, "minimization depth") \
+OPTION( phase,             1,  0,  1,0,0,1, "initial phase") \
+OPTION( probe,             1,  0,  1,0,1,1, "failed literal probing" ) \
+OPTION( probehbr,          1,  0,  1,0,0,1, "learn hyper binary clauses") \
+OPTION( probeint,        5e3,  1,2e9,0,0,1, "probing interval" ) \
+OPTION( probemaxeff,     1e8,  0,2e9,1,0,1, "maximum probing efficiency") \
+OPTION( probemineff,     1e6,  0,2e9,1,0,1, "minimum probing efficiency") \
+OPTION( probereleff,      20,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( proberounds,       1,  1, 16,1,0,1, "probing rounds" ) \
+OPTION( profile,           2,  0,  4,0,0,0, "profiling level") \
+QUTOPT( quiet,             0,  0,  1,0,0,0, "disable all messages") \
+OPTION( radixsortlim,    800,  0,2e9,0,0,1, "radix sort limit") \
+OPTION( realtime,          0,  0,  1,0,0,0, "real instead of process time") \
+OPTION( reduce,            1,  0,  1,0,0,1, "reduce useless clauses") \
+OPTION( reduceint,       300, 10,1e6,0,0,1, "reduce interval") \
+OPTION( reducetarget,     75, 10,1e2,0,0,1, "reduce fraction in percent") \
+OPTION( reducetier1glue,   2,  1,2e9,0,0,1, "glue of kept learned clauses") \
+OPTION( reducetier2glue,   6,  1,2e9,0,0,1, "glue of tier two clauses") \
+OPTION( reluctant,      1024,  0,2e9,0,0,1, "reluctant doubling period") \
+OPTION( reluctantmax,1048576,  0,2e9,0,0,1, "reluctant doubling period") \
+OPTION( rephase,           1,  0,  1,0,0,1, "enable resetting phase") \
+OPTION( rephaseint,      1e3,  1,2e9,0,0,1, "rephase interval") \
+OPTION( report,reportdefault,  0,  1,0,0,1, "enable reporting") \
+OPTION( reportall,         0,  0,  1,0,0,1, "report even if not successful") \
+OPTION( reportsolve,       0,  0,  1,0,0,1, "use solving not process time") \
+OPTION( restart,           1,  0,  1,0,0,1, "enable restarts") \
+OPTION( restartint,        2,  1,2e9,0,0,1, "restart interval") \
+OPTION( restartmargin,    10,  0,1e2,0,0,1, "slow fast margin in percent") \
+OPTION( restartreusetrail, 1,  0,  1,0,0,1, "enable trail reuse") \
+OPTION( restoreall,        0,  0,  2,0,0,1, "restore all clauses (2=really)") \
+OPTION( restoreflush,      0,  0,  1,0,0,1, "remove satisfied clauses") \
+OPTION( reverse,           0,  0,  1,0,0,1, "reverse variable ordering") \
+OPTION( score,             1,  0,  1,0,0,1, "use EVSIDS scores") \
+OPTION( scorefactor,     950,500,1e3,0,0,1, "score factor per mille") \
+OPTION( seed,              0,  0,2e9,0,0,1, "random seed") \
+OPTION( shuffle,           0,  0,  1,0,0,1, "shuffle variables") \
+OPTION( shufflequeue,      1,  0,  1,0,0,1, "shuffle variable queue") \
+OPTION( shufflerandom,     0,  0,  1,0,0,1, "not reverse but random") \
+OPTION( shufflescores,     1,  0,  1,0,0,1, "shuffle variable scores") \
+OPTION( stabilize,         1,  0,  1,0,0,1, "enable stabilizing phases") \
+OPTION( stabilizefactor, 200,101,2e9,0,0,1, "phase increase in percent") \
+OPTION( stabilizeint,    1e3,  1,2e9,0,0,1, "stabilizing interval") \
+OPTION( stabilizemaxint, 2e9,  1,2e9,0,0,1, "maximum stabilizing phase") \
+OPTION( stabilizeonly,     0,  0,  1,0,0,1, "only stabilizing phases") \
+OPTION( stabilizephase,    1,  0,  1,0,0,1, "use target variable phase") \
+OPTION( subsume,           1,  0,  1,0,1,1, "enable clause subsumption") \
+OPTION( subsumebinlim,   1e4,  0,2e9,1,0,1, "watch list length limit") \
+OPTION( subsumeclslim,   1e2,  0,2e9,2,0,1, "clause length limit") \
+OPTION( subsumeint,      1e4,  1,2e9,0,0,1, "subsume interval") \
+OPTION( subsumelimited,    1,  0,  1,0,0,1, "limit subsumption checks") \
+OPTION( subsumemaxeff,   1e8,  0,2e9,1,0,1, "maximum subsuming efficiency") \
+OPTION( subsumemineff,   1e6,  0,2e9,1,0,1, "minimum subsuming efficiency") \
+OPTION( subsumeocclim,   1e2,  0,2e9,1,0,1, "watch list length limit") \
+OPTION( subsumereleff,   1e3,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( subsumestr,        1,  0,  1,0,0,1, "strengthen during subsume") \
+OPTION( terminateint,     10,  0,1e4,0,0,1, "termination check interval") \
+OPTION( ternary,           1,  0,  1,0,1,1, "hyper ternary resolution") \
+OPTION( ternarymaxadd,   1e3,  0,1e4,1,0,1, "max clauses added in percent") \
+OPTION( ternarymaxeff,   1e8,  0,2e9,1,0,1, "ternary maximum efficiency") \
+OPTION( ternarymineff,   1e6,  1,2e9,1,0,1, "minimum ternary efficiency") \
+OPTION( ternaryocclim,   1e2,  1,2e9,2,0,1, "ternary occurrence limit") \
+OPTION( ternaryreleff,    10,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( ternaryrounds,     2,  1, 16,1,0,1, "maximum ternary rounds") \
+OPTION( transred,          1,  0,  1,0,1,1, "transitive reduction of BIG") \
+OPTION( transredmaxeff,  1e8,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( transredmineff,  1e6,  0,2e9,1,0,1, "minimum efficiency") \
+OPTION( transredreleff,  1e2,  1,1e5,1,0,1, "relative efficiency per mille") \
+QUTOPT( verbose,           0,  0,  3,0,0,0, "more verbose messages") \
+OPTION( vivify,            1,  0,  1,0,1,1, "vivification") \
+OPTION( vivifymaxeff,    2e7,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( vivifymineff,    2e4,  0,2e9,1,0,1, "minimum efficiency") \
+OPTION( vivifyonce,        0,  0,  2,0,0,1, "vivify once: 1=red, 2=red+irr") \
+OPTION( vivifyredeff,     75,  0,1e3,1,0,1, "redundant efficiency per mille") \
+OPTION( vivifyreleff,     20,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( walk,              1,  0,  1,0,0,1, "enable random walks") \
+OPTION( walkmaxeff,      1e7,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( walkmineff,      1e5,  0,1e7,1,0,1, "minimum efficiency") \
+OPTION( walknonstable,     1,  0,  1,0,0,1, "walk in non-stabilizing phase") \
+OPTION( walkredundant,     0,  0,  1,0,0,1, "walk redundant clauses too") \
+OPTION( walkreleff,       20,  1,1e5,1,0,1, "relative efficiency per mille") \
 
 // Note, keep an empty line right before this line because of the last '\'!
 // Also keep those single spaces after 'OPTION(' for proper sorting.
@@ -216,7 +217,9 @@ class Options;
 
 struct Option {
   const char * name;
-  int def, lo, hi, optimizable;
+  int def, lo, hi;
+  int optimizable;
+  bool preprocessing;
   const char * description;
   int & val (Options *);
 };
@@ -226,7 +229,7 @@ struct Option {
 // Produce a compile time constant for the number of options.
 
 static const size_t number_of_options =
-#define OPTION(N,V,L,H,O,D) 1 +
+#define OPTION(N,V,L,H,O,P,R,D) 1 +
 OPTIONS
 #undef OPTION
 + 0;
@@ -245,13 +248,22 @@ class Options {
   static void initialize_from_environment (
     int & val, const char * name, const int L, const int H);
 
+  friend Config;
+
+  void reset_default_values ();
+  void disable_preprocessing ();
+
 public:
 
   // For library usage we disable reporting by default while for the stand
   // alone SAT solver we enable it by default.  This default value has to
-  // be set before the constructor of 'Options' is called.
+  // be set before the constructor of 'Options' is called (which in turn is
+  // called from the constructor of 'Solver').  If we would simply overwrite
+  // its initial value while initializing the stand alone solver,  we will
+  // get that change of the default value (from 'false' to 'true') shown
+  // during calls to 'print ()', which is confusing to the user.
   //
-  static int report_default_value;
+  static int reportdefault;
 
   Options (Internal *);
 
@@ -259,8 +271,10 @@ class Options {
   // member 'int restart' here.  This will give fast access to option values
   // internally in the solver and thus can also be used in tight loops.
   //
+private:
   int __start_of_options__;             // Used by 'val' below.
-# define OPTION(N,V,L,H,O,D) \
+public:
+# define OPTION(N,V,L,H,O,P,R,D) \
   int N;                                // Access option values by name.
   OPTIONS
 # undef OPTION
@@ -268,7 +282,8 @@ class Options {
   // It would be more elegant to use an anonymous 'struct' of the actual
   // option values overlayed with an 'int values[number_of_options]' array
   // but that is not proper ISO C++ and produces a warning.  Instead we use
-  // the following construction which relies on '__start_of_options__'.
+  // the following construction which relies on '__start_of_options__' and
+  // that the following options are really allocated directly after it.
   //
   inline int & val (size_t idx) {
     assert (idx < number_of_options);
@@ -280,33 +295,21 @@ class Options {
   // search over the sorted option 'table'.  This static data is shared
   // among different instances of the solver.  The actual current option
   // values are here in the 'Options' class.  They can be accessed by the
-  // offset of the static options through the 'vals' field using
-  // 'Option::val' if you have an 'Option' or to have even faster access
-  // directly by the member function (the 'N' above, e.g., 'restart').
+  // offset of the static options using 'Option::val' if you have an
+  // 'Option' or to have even faster access directly by the member function
+  // (the 'N' above, e.g., 'restart').
   //
   static Option * has (const char * name);
 
   bool set (const char * name, int);    // Explicit version.
   int  get (const char * name);         // Get current value.
 
-  void config (const char * name);      // Configuration.
-
   void print ();             // Print current values in command line form
   static void usage ();      // Print usage message for all options.
 
   void optimize (int val);   // increase some limits (val=0..31)
 
-  // Parse option value string in the form of
-  //
-  //   true
-  //   false
-  //   [-]<mantissa>[e<exponent>]
-  //
-  // and in the latter case '<val>' has to be within [-INT_MAX,INT_MAX].
-  // The function returns true if parsing is successful and then also sets
-  // the second argument to the parsed value.
-  //
-  static bool parse_option_value (const char *, int &);
+  static bool is_preprocessing_option (const char * name);
 
   // Parse long option argument
   //
@@ -327,6 +330,8 @@ class Options {
 
   static iterator begin () { return table; }
   static iterator end () { return table + number_of_options; }
+
+  void copy (Options & other) const;    // Copy 'this' into 'other'.
 };
 
 inline int & Option::val (Options * opts) {
diff --git a/src/parse.cpp b/src/parse.cpp
index 04d46b5d..248f77d0 100644
--- a/src/parse.cpp
+++ b/src/parse.cpp
@@ -28,6 +28,7 @@ inline const char *
 Parser::parse_string (const char * str, char prev) {
   for (const char * p = str; *p; p++)
     if (parse_char () == *p) prev = *p;
+    else if (*p == ' ') PER ("expected space after '%c'", prev);
     else PER ("expected '%c' after '%c'", *p, prev);
   return 0;
 }
@@ -45,8 +46,12 @@ Parser::parse_positive_int (int & ch, int & res, const char * name) {
   return 0;
 }
 
+static const char * cube_token = "unexpected 'a' in CNF";
+
 inline const char *
-Parser::parse_lit (int & ch, int & lit, const int vars, int strict) {
+Parser::parse_lit (int & ch, int & lit, int & vars, int strict) {
+  if (ch == 'a')
+    return cube_token;
   int sign = 0;
   if (ch == '-') {
     if (!isdigit (ch = parse_char ())) PER ("expected digit after '-'");
@@ -63,8 +68,11 @@ Parser::parse_lit (int & ch, int & lit, const int vars, int strict) {
   if (ch == '\r') ch = parse_char ();
   if (ch != 'c' && ch != ' ' && ch != '\t' && ch != '\n' && ch != EOF)
     PER ("expected white space after '%d'", sign*lit);
-  if (lit > vars && strict > 0)
-    PER ("literal %d exceeds maximum variable %d", sign*lit, vars);
+  if (lit > vars) {
+    if (strict != FORCED)
+      PER ("literal %d exceeds maximum variable %d", sign*lit, vars);
+    else vars = lit;
+  }
   lit *= sign;
   return 0;
 }
@@ -76,9 +84,10 @@ Parser::parse_lit (int & ch, int & lit, const int vars, int strict) {
 const char * Parser::parse_dimacs_non_profiled (int & vars, int strict) {
 
 #ifndef QUIET
-  const double start = internal->time ();
+  double start = internal->time ();
 #endif
 
+  bool found_inccnf_header = false;
   int ch, clauses = 0;
   vars = 0;
 
@@ -86,7 +95,8 @@ const char * Parser::parse_dimacs_non_profiled (int & vars, int strict) {
   //
   for (;;) {
     ch = parse_char ();
-    if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') continue;
+    if (strict != STRICT)
+      if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') continue;
     if (ch != 'c') break;
     string buf;
     while ((ch = parse_char ()) != '\n')
@@ -100,57 +110,98 @@ const char * Parser::parse_dimacs_non_profiled (int & vars, int strict) {
     if (*o) solver->set_long_option (o);
   }
 
-  // Now read 'p cnf <var> <clauses>' header of DIMACS file.
-  //
   if (ch != 'p') PER ("expected 'c' or 'p'");
 
-  if (strict > 1) {
-    const char * err = parse_string (" cnf ", 'p');
-    if (err) return err;
-    ch = parse_char ();
-    if (!isdigit (ch)) PER ("expected digit after 'p cnf '");
-    err = parse_positive_int (ch, vars, "<max-var>");
-    if (err) return err;
-    if (ch != ' ') PER ("expected ' ' after 'p cnf %d'", vars);
-    if (!isdigit (ch = parse_char ()))
-      PER ("expected digit after 'p cnf %d '", vars);
-    err = parse_positive_int (ch, clauses, "<num-clauses>");
-    if (err) return err;
-    if (ch != '\n')
-      PER ("expected new-line after 'p cnf %d %d'", vars, clauses);
-  } else {
+  ch = parse_char ();
+  if (strict == STRICT) {
+    if (ch != ' ') PER ("expected space after 'p'");
     ch = parse_char ();
-    if (!isspace (ch)) PER ("expected space after 'p'");
-    do ch = parse_char (); while (isspace (ch));
-    if (ch != 'c') PER ("expected 'c' after 'p '");
-    if (parse_char () != 'n') PER ("expected 'n' after 'p c'");
-    if (parse_char () != 'f') PER ("expected 'f' after 'p cn'");
-    ch = parse_char ();
-    if (!isspace (ch)) PER ("expected space after 'p cnf'");
-    do ch = parse_char (); while (isspace (ch));
-    if (!isdigit (ch)) PER ("expected digit after 'p cnf '");
-    const char * err = parse_positive_int (ch, vars, "<max-var>");
-    if (err) return err;
-    if (!isspace (ch)) PER ("expected space after 'p cnf %d'", vars);
-    do ch = parse_char (); while (isspace (ch));
-    if (!isdigit (ch)) PER ("expected digit after 'p cnf %d '", vars);
-    err = parse_positive_int (ch, clauses, "<num-clauses>");
-    if (err) return err;
-    while (ch != '\n') {
-      if (ch != '\r' && !isspace (ch))
-        PER ("expected new-line after 'p cnf %d %d'", vars, clauses);
-      ch = parse_char ();
-    }
+  } else if (ch != ' ' && ch != '\t')
+    PER ("expected white space after 'p'");
+  else {
+    do ch = parse_char (); while (ch == ' ' || ch == '\t');
   }
 
-  MSG ("found %s'p cnf %d %d'%s header",
-    tout.green_code (), vars, clauses, tout.normal_code ());
+  // Now read 'p cnf <var> <clauses>' header of DIMACS file
+  // or 'p inccnf' of incremental 'INCCNF' file.
+  //
+  if (ch == 'c')
+    {
+      assert (!found_inccnf_header);
+      if (strict == STRICT) {
+	const char * err = parse_string ("nf ", 'c');
+	if (err) return err;
+	ch = parse_char ();
+	if (!isdigit (ch)) PER ("expected digit after 'p cnf '");
+	err = parse_positive_int (ch, vars, "<max-var>");
+	if (err) return err;
+	if (ch != ' ') PER ("expected ' ' after 'p cnf %d'", vars);
+	if (!isdigit (ch = parse_char ()))
+	  PER ("expected digit after 'p cnf %d '", vars);
+	err = parse_positive_int (ch, clauses, "<num-clauses>");
+	if (err) return err;
+	if (ch != '\n')
+	  PER ("expected new-line after 'p cnf %d %d'", vars, clauses);
+      } else {
+	if (parse_char () != 'n') PER ("expected 'n' after 'p c'");
+	if (parse_char () != 'f') PER ("expected 'f' after 'p cn'");
+	ch = parse_char ();
+	if (!isspace (ch)) PER ("expected space after 'p cnf'");
+	do ch = parse_char (); while (isspace (ch));
+	if (!isdigit (ch)) PER ("expected digit after 'p cnf '");
+	const char * err = parse_positive_int (ch, vars, "<max-var>");
+	if (err) return err;
+	if (!isspace (ch)) PER ("expected space after 'p cnf %d'", vars);
+	do ch = parse_char (); while (isspace (ch));
+	if (!isdigit (ch)) PER ("expected digit after 'p cnf %d '", vars);
+	err = parse_positive_int (ch, clauses, "<num-clauses>");
+	if (err) return err;
+	while (ch != '\n') {
+	  if (ch != '\r' && !isspace (ch))
+	    PER ("expected new-line after 'p cnf %d %d'", vars, clauses);
+	  ch = parse_char ();
+	}
+      }
+
+      MSG ("found %s'p cnf %d %d'%s header",
+	tout.green_code (), vars, clauses, tout.normal_code ());
+
+      if (strict != FORCED)
+	solver->reserve (vars);
+    }
+  else if (!parse_inccnf_too)
+    PER ("expected 'c' after 'p '");
+  else if (ch == 'i')
+    {
+      found_inccnf_header = true;
+      const char * err = parse_string ("nccnf", 'i');
+      if (err) return err;
+      ch = parse_char ();
+      if (strict == STRICT) {
+	if (ch != '\n')
+	  PER ("expected new-line after 'p inccnf'");
+      } else {
+	while (ch != '\n')
+	  {
+	    if (ch != '\r' && !isspace (ch))
+	      PER ("expected new-line after 'p inccnf'");
+	    ch = parse_char ();
+	  }
+      }
+
+      MSG ("found %s'p inccnf'%s header",
+	tout.green_code (), tout.normal_code ());
+
+      strict = FORCED;
+    }
+  else
+    PER ("expected 'c' or 'i' after 'p '");
 
-  solver->reserve (vars);
+  if (parse_inccnf_too)
+    *parse_inccnf_too = false;
 
-  // Now read body of DIMACS file.
+  // Now read body of DIMACS part.
   //
-  // external->init (vars);
   int lit = 0, parsed = 0;
   while ((ch = parse_char ()) != EOF) {
     if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') continue;
@@ -160,6 +211,7 @@ const char * Parser::parse_dimacs_non_profiled (int & vars, int strict) {
       if (ch == EOF) break;
       continue;
     }
+    if (ch == 'a' && found_inccnf_header) break;
     const char * err = parse_lit (ch, lit, vars, strict);
     if (err) return err;
     if (ch == 'c') {
@@ -168,18 +220,82 @@ const char * Parser::parse_dimacs_non_profiled (int & vars, int strict) {
           PER ("unexpected end-of-file in comment");
     }
     solver->add (lit);
-    if (!lit && parsed++ >= clauses && strict > 0)
+    if (!found_inccnf_header && 
+        !lit && parsed++ >= clauses && strict != FORCED)
       PER ("too many clauses");
   }
+
   if (lit) PER ("last clause without terminating '0'");
-  if (parsed < clauses && strict > 0) PER ("clause missing");
+
+  if (!found_inccnf_header && parsed < clauses && strict != FORCED)
+    PER ("clause missing");
 
 #ifndef QUIET
-  const double end = internal->time ();
+  double end = internal->time ();
   MSG ("parsed %d clauses in %.2f seconds %s time",
     parsed, end - start, internal->opts.realtime ? "real" : "process");
 #endif
 
+#ifndef QUIET
+  start = end;
+#endif
+  size_t num_cubes = 0;
+  if (ch == 'a') {
+    assert (parse_inccnf_too);
+    assert (found_inccnf_header);
+    if (!*parse_inccnf_too) *parse_inccnf_too = true;
+    for (;;) {
+      ch = parse_char ();
+      if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+	continue;
+      if (ch == 'c') {
+	while ((ch = parse_char ()) != '\n' && ch != EOF)
+	  ;
+	if (ch == EOF) break;
+	continue;
+      }
+      const char * err = parse_lit (ch, lit, vars, strict);
+      if (err == cube_token) PER ("two 'a' in a row");
+      else if (err) return err;
+      if (ch == 'c') {
+	while ((ch = parse_char ()) != '\n')
+	  if (ch == EOF)
+	    PER ("unexpected end-of-file in comment");
+      }
+      if (cubes)
+	cubes->push_back (lit);
+      if (!lit) {
+	num_cubes++;
+	for (;;)
+	  {
+	    ch = parse_char ();
+	    if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+	      continue;
+	    if (ch == 'c') {
+	      while ((ch = parse_char ()) != '\n' && ch != EOF)
+		;
+	      if (ch == EOF) break;
+	    }
+	    if (ch == EOF) break;
+	    if (ch != 'a')
+	      PER ("expected 'a' or end-of-file after zero");
+	    lit = INT_MIN;
+	    break;
+	  }
+	if (ch == EOF) break;
+      }
+    }
+    if (lit) PER ("last cube without terminating '0'");
+  }
+#ifndef QUIET
+  if (found_inccnf_header)
+    {
+      double end = internal->time ();
+      MSG ("parsed %zd cubes in %.2f seconds %s time",
+	num_cubes, end - start, internal->opts.realtime ? "real" : "process");
+    }
+#endif
+
   return 0;
 }
 
@@ -188,8 +304,8 @@ const char * Parser::parse_dimacs_non_profiled (int & vars, int strict) {
 // Parsing solution in competition output format.
 
 const char * Parser::parse_solution_non_profiled () {
-  external->solution = new signed char [ external->max_var + 1 ];
-  clear_n (external->solution, external->max_var + 1);
+  external->solution = new signed char [ external->max_var + 1u ];
+  clear_n (external->solution, external->max_var + 1u);
   int ch;
   for (;;) {
     ch = parse_char ();
@@ -236,6 +352,7 @@ const char * Parser::parse_solution_non_profiled () {
 // implicit 'return' in PER in the non-profiled versions.
 
 const char * Parser::parse_dimacs (int & vars, int strict) {
+  assert (strict == FORCED || strict == RELAXED || strict == STRICT);
   START (parse);
   const char * err = parse_dimacs_non_profiled (vars, strict);
   STOP (parse);
diff --git a/src/parse.hpp b/src/parse.hpp
index 7cbb7311..2e435a0a 100644
--- a/src/parse.hpp
+++ b/src/parse.hpp
@@ -1,6 +1,9 @@
 #ifndef _parse_hpp_INCLUDED
 #define _parse_hpp_INCLUDED
 
+#include <cassert>
+#include <vector>
+
 namespace CaDiCaL {
 
 // Factors out common functions for parsing of DIMACS and solution files.
@@ -19,20 +22,41 @@ class Parser {
   void perr (const char * fmt, ...);
   int parse_char ();
 
+  enum {
+    FORCED = 0,         // Force reading even if header is broken.
+    RELAXED = 1,        // Relaxed white space treatment in header.
+    STRICT = 2,         // Strict white space and header compliance.
+  };
+
   const char * parse_string (const char * str, char prev);
   const char * parse_positive_int (int & ch, int & res, const char * name);
-  const char * parse_lit (int & ch, int & lit, const int vars, int strict);
+  const char * parse_lit (int & ch, int & lit, int & vars, int strict);
   const char * parse_dimacs_non_profiled (int & vars, int strict);
   const char * parse_solution_non_profiled ();
 
+  bool * parse_inccnf_too;
+  vector<int> * cubes;
+
 public:
 
-  Parser (Solver * s, File * f) :
-    solver (s), internal (s->internal), external (s->external), file (f)
-  { }
+  // Parse a DIMACS CNF or ICNF file.
+  //
+  // Return zero if successful. Otherwise parse error.
+   Parser(Solver *s, File *f, bool *i, vector<int> *c) :
+     solver(s), internal(s->internal), external(s->external), file(f),
+    parse_inccnf_too (i), cubes (c)
+  {}
 
-  // Parse a DIMACS file.  Return zero if successful. Otherwise parse error.
-  // The clauses are added.
+  // Parse a DIMACS file.  Return zero if successful. Otherwise a parse
+  // error is return. The parsed clauses are added to the solver and the
+  // maximum variable index found is return in the 'vars' argument. The
+  // 'strict' argument can be '0' in which case the numbers in the header
+  // can be arbitrary, e.g., 'p cnf 0 0' all the time, without producing a
+  // parse error.  Only for this setting the parsed literals are not checked
+  // to overflow the maximum variable index of the header.  The strictest
+  // form of parsing is enforced  for the value '2' of 'strict', in which
+  // case the header can not have additional white space, while a value of
+  // '1' exactly relaxes this, e.g., 'p cnf \t  1   3  \r\n' becomes legal.
   //
   const char * parse_dimacs (int & vars, int strict);
 
diff --git a/src/phases.cpp b/src/phases.cpp
index 6636d069..dc768db8 100644
--- a/src/phases.cpp
+++ b/src/phases.cpp
@@ -4,16 +4,35 @@ namespace CaDiCaL {
 
 void Internal::copy_phases (vector<signed char> & dst) {
   START (copy);
-  for (int i = 1; i <= max_var; i++)
-    dst[i] = vals[i];
+  for (auto i : vars)
+    dst[i] = phases.saved[i];
   STOP (copy);
 }
 
 void Internal::clear_phases (vector<signed char> & dst) {
   START (copy);
-  for (int i = 1; i <= max_var; i++)
+  for (auto i : vars)
     dst[i] = 0;
   STOP (copy);
 }
 
+void Internal::phase (int lit) {
+  const int idx = vidx (lit);
+  signed char old_forced_phase = phases.forced[idx];
+  signed char new_forced_phase = sign (lit);
+  if (old_forced_phase == new_forced_phase) return;
+  if (old_forced_phase)
+    LOG ("overwriting old forced phase %d", old_forced_phase * idx);
+  LOG ("new forced phase %d", new_forced_phase * idx);
+  phases.forced[idx] = new_forced_phase;
+}
+
+void Internal::unphase (int lit) {
+  const int idx = vidx (lit);
+  signed char old_forced_phase = phases.forced[idx];
+  if (!old_forced_phase) return;
+  LOG ("clearing old forced phase %d", old_forced_phase * idx);
+  phases.forced[idx] = 0;
+}
+
 }
diff --git a/src/phases.hpp b/src/phases.hpp
index a6ab94c4..821abf96 100644
--- a/src/phases.hpp
+++ b/src/phases.hpp
@@ -5,11 +5,12 @@ namespace CaDiCaL {
 
 struct Phases {
 
-  vector<signed char> saved;   // The actual saved phase.
-  vector<signed char> target;  // The current target phase.
   vector<signed char> best;    // The current largest trail phase.
-  vector<signed char> prev;    // Previous during local search.
+  vector<signed char> forced;  // Forced through 'phase'.
   vector<signed char> min;     // The current minimum unsatisfied phase.
+  vector<signed char> prev;    // Previous during local search.
+  vector<signed char> saved;   // The actual saved phase.
+  vector<signed char> target;  // The current target phase.
 
 };
 
diff --git a/src/probe.cpp b/src/probe.cpp
index 625b7761..b44c847e 100644
--- a/src/probe.cpp
+++ b/src/probe.cpp
@@ -14,7 +14,6 @@ namespace CaDiCaL {
 /*------------------------------------------------------------------------*/
 
 bool Internal::probing () {
-  if (!opts.simplify) return false;
   if (!opts.probe) return false;
   if (!preprocessing && !opts.inprocessing) return false;
   if (preprocessing) assert (lim.preprocessing);
@@ -25,6 +24,21 @@ bool Internal::probing () {
 
 /*------------------------------------------------------------------------*/
 
+inline int Internal::get_parent_reason_literal (int lit) {
+  const int idx = vidx (lit);
+  int res = parents[idx];
+  if (lit < 0) res = -res;
+  return res;
+}
+
+inline void Internal::set_parent_reason_literal (int lit, int reason) {
+  const int idx = vidx (lit);
+  if (lit < 0) reason = -reason;
+  parents[idx] = reason;
+}
+
+/*------------------------------------------------------------------------*/
+
 // On-the-fly (dynamic) hyper binary resolution on decision level one can
 // make use of the fact that the implication graph is actually a tree.
 
@@ -38,9 +52,8 @@ int Internal::probe_dominator (int a, int b) {
   assert (u->level == 1), assert (v->level == 1);
   while (l != k) {
     if (u->trail > v->trail) swap (l, k), swap (u, v);
-    if (!u->parent) return l;
-    int parent = v->parent;
-    if (k < 0) parent = -parent;
+    if (!get_parent_reason_literal (l)) return l;
+    int parent = get_parent_reason_literal (k);
     assert  (parent), assert (val (parent) > 0);
     v = &var (k = parent);
     assert (v->level == 1);
@@ -164,10 +177,10 @@ inline void Internal::probe_assign (int lit, int parent) {
   Var & v = var (idx);
   v.level = level;
   v.trail = (int) trail.size ();
-  const signed char tmp = sign (lit);
-  v.parent = tmp < 0 ? -parent : parent;
+  set_parent_reason_literal (lit, parent);
   if (!level) learn_unit_clause (lit);
   else assert (level == 1);
+  const signed char tmp = sign (lit);
   vals[idx] = tmp;
   vals[-idx] = -tmp;
   assert (val (lit) > 0);
@@ -248,7 +261,7 @@ bool Internal::probe_propagate () {
         if (w.clause->garbage) continue;
         const literal_iterator lits = w.clause->begin ();
         const int other = lits[0]^lits[1]^lit;
-        lits[0] = other, lits[1] = lit;
+        //lits[0] = other, lits[1] = lit;
         const signed char u = val (other);
         if (u > 0) ws[j-1].blit = other;
         else {
@@ -272,11 +285,13 @@ bool Internal::probe_propagate () {
           else if (!v) {
             LOG (w.clause, "unwatch %d in", r);
             *k = lit;
+            lits[0] = other;
             lits[1] = r;
             watch_literal (r, lit, w.clause);
             j--;
           } else if (!u) {
             if (level == 1) {
+              lits[0] = other, lits[1] = lit;
               int dom = hyper_binary_resolve (w.clause);
               probe_assign (other, dom);
             } else probe_assign_unit (other);
@@ -326,14 +341,13 @@ void Internal::failed_literal (int failed) {
   LOG ("found probing UIP %d", uip);
   assert (uip);
 
-  vector<int> parents;
+  vector<int> work;
   int parent = uip;
   while (parent != failed) {
-    int next = var (parent).parent;
-    if (parent < 0) next = -next;
+    const int next = get_parent_reason_literal (parent);
     parent = next;
     assert (parent);
-    parents.push_back (parent);
+    work.push_back (parent);
   }
 
   backtrack ();
@@ -345,9 +359,9 @@ void Internal::failed_literal (int failed) {
 
   if (!probe_propagate ()) learn_empty_clause ();
 
-  while (!unsat && !parents.empty ()) {
-    const int parent = parents.back ();
-    parents.pop_back ();
+  while (!unsat && !work.empty ()) {
+    const int parent = work.back ();
+    work.pop_back ();
     const signed char tmp = val (parent);
     if (tmp < 0) continue;
     if (tmp > 0) {
@@ -359,7 +373,7 @@ void Internal::failed_literal (int failed) {
       if (!probe_propagate ()) learn_empty_clause ();
     }
   }
-  erase_vector (parents);
+  erase_vector (work);
 
   STOP (analyze);
 
@@ -413,7 +427,7 @@ void Internal::generate_probes () {
     noccs (b)++;
   }
 
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
 
     // Then focus on roots of the binary implication graph, which are
     // literals occurring negatively in a binary clause, but not positively.
@@ -446,7 +460,7 @@ void Internal::generate_probes () {
 
   PHASE ("probe-round", stats.probingrounds,
     "scheduled %" PRId64 " literals %.0f%%",
-    probes.size (), percent (probes.size (), 2*max_var));
+    probes.size (), percent (probes.size (), 2u*max_var));
 }
 
 // Follow the ideas in 'generate_probes' but flush non root probes and
@@ -531,7 +545,8 @@ int Internal::next_probe () {
 
 bool Internal::probe_round () {
 
-  if (unsat || terminating ()) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
 
   START_SIMPLIFIER (probe, PROBE);
   stats.probingrounds++;
@@ -565,7 +580,7 @@ bool Internal::probe_round () {
   // a new learned clause, which might produce new propagations (and hyper
   // binary resolvents).  During 'generate_probes' we keep the old value.
   //
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     propfixed (idx) = propfixed (-idx) = -1;
 
   assert (unsat || propagated == trail.size ());
@@ -573,7 +588,7 @@ bool Internal::probe_round () {
 
   int probe;
   while (!unsat &&
-         !terminating () &&
+         !terminated_asynchronously () &&
          stats.propagations.probe < limit &&
          (probe = next_probe ())) {
     stats.probed++;
@@ -622,6 +637,8 @@ void CaDiCaL::Internal::probe (bool update_limits) {
 
   stats.probingphases++;
 
+  const int before = active ();
+
   // We trigger equivalent literal substitution (ELS) before ...
   //
   decompose ();
@@ -644,7 +661,20 @@ void CaDiCaL::Internal::probe (bool update_limits) {
 
   if (!update_limits) return;
 
-  int64_t delta = opts.probeint * (stats.probingphases + 1);
+  const int after = active ();
+  const int removed = before - after;
+  assert (removed >= 0);
+
+  if (removed) {
+    stats.probesuccess++;
+    PHASE ("probe-phase", stats.probingphases,
+      "successfully removed %d active variables %.0f%%",
+      removed, percent (removed, before));
+  } else
+    PHASE ("probe-phase", stats.probingphases,
+      "could not remove any active variable");
+
+  const int64_t delta = opts.probeint * (stats.probingphases + 1);
   lim.probe = stats.conflicts + delta;
 
   PHASE ("probe-phase", stats.probingphases,
diff --git a/src/profile.hpp b/src/profile.hpp
index 48166a1d..c1afe27b 100644
--- a/src/profile.hpp
+++ b/src/profile.hpp
@@ -56,6 +56,7 @@ PROFILE(elim,2) \
 PROFILE(extend,3) \
 PROFILE(instantiate,2) \
 PROFILE(lucky,2) \
+PROFILE(lookahead,2) \
 PROFILE(minimize,4) \
 PROFILE(parse,3) \
 PROFILE(probe,2) \
@@ -125,7 +126,7 @@ do { \
 do { \
   const double N = time (); \
   const int L = internal->opts.profile; \
-  if (!preprocessing) { \
+  if (!preprocessing && !lookingahead) { \
     if (stable && internal->profiles.stable.level <= L) \
       internal->stop_profiling (internal->profiles.stable, N); \
     if (!stable && internal->profiles.unstable.level <= L) \
@@ -154,7 +155,7 @@ do { \
     internal->stop_profiling (internal->profiles.simplify, N); \
   reset_mode (M); \
   reset_mode (SIMPLIFY); \
-  if (!preprocessing) { \
+  if (!preprocessing && !lookingahead) { \
     if (internal->profiles.search.level <= L) \
       internal->start_profiling (internal->profiles.search, N); \
     if (stable && internal->profiles.stable.level <= L) \
diff --git a/src/propagate.cpp b/src/propagate.cpp
index 2a64a228..5d426d08 100644
--- a/src/propagate.cpp
+++ b/src/propagate.cpp
@@ -159,8 +159,8 @@ bool Internal::propagate () {
     Watches & ws = watches (lit);
 
     const const_watch_iterator eow = ws.end ();
-    const_watch_iterator i = ws.begin ();
     watch_iterator j = ws.begin ();
+    const_watch_iterator i = j;
 
     while (i != eow) {
 
@@ -221,9 +221,7 @@ bool Internal::propagate () {
         //
         // which achieves the same effect, but needs a branch.
         //
-        const int other = lits[0]^lits[1]^lit;
-        lits[0] = other, lits[1] = lit;
-
+        const int other = lits[0] ^ lits[1] ^ lit;
         const signed char u = val (other); // value of the other watch
 
         if (u > 0) j[-1].blit = other; // satisfied, just replace blit
@@ -274,8 +272,10 @@ bool Internal::propagate () {
 
             LOG (w.clause, "unwatch %d in", lit);
 
+            lits[0] = other;
             lits[1] = r;
             *k = lit;
+
             watch_literal (r, lit, w.clause);
 
             j--;  // Drop this watch from the watch list of 'lit'.
@@ -306,8 +306,6 @@ bool Internal::propagate () {
                 // level and watch that instead of 'lit'.
 
                 assert (size > 2);
-                assert (lits[0] == other);
-                assert (lits[1] == lit);
 
                 int pos, s = 0;
 
@@ -320,6 +318,7 @@ bool Internal::propagate () {
 
                 LOG (w.clause, "unwatch %d in", lit);
                 lits[pos] = lit;
+                lits[0] = other;
                 lits[1] = s;
                 watch_literal (s, other, w.clause);
 
diff --git a/src/random.hpp b/src/random.hpp
index b1b4aeec..a371347f 100644
--- a/src/random.hpp
+++ b/src/random.hpp
@@ -44,13 +44,33 @@ class Random {
   //
   int pick_int (int l, int r) {
     assert (l <= r);
-    int res = (r + 1.0 - l) * (generate () / 4294967296.0);
-    res += l;
+    const unsigned delta = 1 + r - (unsigned) l;
+    unsigned tmp = generate (), scaled;
+    if (delta) {
+      const double fraction = tmp / 4294967296.0;
+      scaled = delta * fraction;
+    } else scaled = tmp;
+    const int res = scaled + l;
     assert (l <= res);
     assert (res <= r);
     return res;
   }
 
+  int pick_log (int l, int r) {
+    assert (l <= r);
+    const unsigned delta = 1 + r - (unsigned) l;
+    int log_delta = delta ? 0 : 32;
+    while (log_delta < 32 && (1u << log_delta) < delta)
+      log_delta++;
+    const int log_res = pick_int (0, log_delta);
+    unsigned tmp = generate ();
+    if (log_res < 32) tmp &= (1u << log_res) - 1;
+    if (delta) tmp %= delta;
+    const int res = l + tmp;
+    assert (l <= res), assert (res <= r);
+    return res;
+  }
+
   // Generate 'double' value in the range '[l,r]'.
   //
   double pick_double (double l, double r) {
diff --git a/src/range.hpp b/src/range.hpp
new file mode 100644
index 00000000..d3a23b05
--- /dev/null
+++ b/src/range.hpp
@@ -0,0 +1,93 @@
+#ifndef _range_hpp_INCLUDED
+#define _range_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Clause;
+
+/*----------------------------------------------------------------------*/
+
+// Used for compact and safe iteration over positive ranges of integers,
+// particularly for iterating over all variable indices.
+//
+//   Range vars (max_var);
+//   for (auto idx : vars) ....
+//
+// This iterates over '1, ..., max_var' and is safe for non-negative
+// numbers, such also for 'max_var == 0' or 'max_var == INT_MAX'.
+//
+// Note that
+//
+//   for (int idx = 1; idx <= max_var; idx++) ...
+//
+// leads to an overflow if 'max_var == INT_MAX' and thus depending on what
+// the compiler does ('int' overflow is undefined) might lead to any
+// behaviour (infinite loop or worse array access way out of bounds).
+//
+// If we make 'idx' in this last 'for' loop an 'unsigned' then it is safe to
+// use this idiom, but we would need to cast 'max_var' explicitly to 'int'
+// in order to avoid a warning in the loop condition and actually everywhere
+// where 'idx' is compared to a 'signed' expression.  Worse for instance
+// 'vals[-idx]' will lead to out of bounds access too.  This is awkward and
+// using the range iterator provided here is safer in general.
+//
+// Another issue is that the dereferencing operator '*' below is required to
+// return a reference to the internal index of the iterator.  Thus the 'idx'
+// in the auto loop is actually of the same type as the internal state of
+// the iterator.  To keep it 'signed' and still avoid overflow issues we
+// just have to make sure to use the proper increment (with two implicit
+// casts, i.e., from 'int' to 'unsigned', then 'unsigned' addition and the
+// result is cast back from 'unsigned' to 'int').
+//
+// For simplicity we keep a reference to the actual maximum integer, e.g.,
+// 'max_var', which makes the idiom 'for (auto idx : vars) ...' possible.
+// Further note that the referenced integer has to be non-negative before
+// starting to iterate (it can be zero though), otherwise it breaks.
+
+class Range {
+  static unsigned inc (unsigned u) { return u + 1u; }
+  class iterator {
+    int idx;
+  public:
+    iterator (int i) : idx (i) { }
+    void operator++ () { idx = inc (idx); }
+    const int & operator* () const { return idx; }
+    friend bool operator != (const iterator & a, const iterator & b) {
+      return a.idx != b.idx;
+    }
+  };
+  int & n;
+public:
+  iterator begin () const { return assert (n >= 0), iterator (inc (0)); }
+  iterator end ()   const { return assert (n >= 0), iterator (inc (n)); }
+  Range (int & m) : n (m) { assert (m >= 0); }
+};
+
+// Same, but iterating over literals '-1,1,-2,2,....,-max_var,max_var'.
+//
+// The only difference to 'Range' is the 'inc' function, but I am too lazy
+// to figure out how to properly factor the code into a generic range
+// template with 'inc' as only parameter.  This gives at least clean code.
+
+class Sange {
+  static unsigned inc (unsigned u) { return ~u + (u >> 31); }
+  class iterator {
+    int lit;
+  public:
+    iterator (int i) : lit (i) { }
+    void operator++ () { lit = inc (lit); }
+    const int & operator* () const { return lit; }
+    friend bool operator != (const iterator & a, const iterator & b) {
+      return a.lit != b.lit;
+    }
+  };
+  int & n;
+public:
+  iterator begin () const { return assert (n >= 0), iterator (inc (0)); }
+  iterator end ()   const { return assert (n >= 0), iterator (inc (n)); }
+  Sange (int & m) : n (m) { assert (m >= 0); }
+};
+
+}
+
+#endif
diff --git a/src/reduce.cpp b/src/reduce.cpp
index fa2cffe7..c7efffe0 100644
--- a/src/reduce.cpp
+++ b/src/reduce.cpp
@@ -28,28 +28,6 @@ bool Internal::flushing () {
 
 /*------------------------------------------------------------------------*/
 
-// Reason clauses (on non-zero decision level) can not be collected.
-// We protect them before and unprotect them after garbage collection.
-
-void Internal::protect_reasons () {
-  for (const auto & lit : trail) {
-    Var & v = var (lit);
-    if (!v.level || !v.reason) continue;
-    LOG (v.reason, "protecting");
-    v.reason->reason = true;
-  }
-}
-
-void Internal::unprotect_reasons () {
-  for (const auto & lit : trail) {
-    Var & v = var (lit);
-    if (!v.level || !v.reason) continue;
-    assert (v.reason->reason), v.reason->reason = false;
-  }
-}
-
-/*------------------------------------------------------------------------*/
-
 void Internal::mark_clauses_to_be_flushed () {
   for (const auto & c : clauses) {
     if (!c->redundant) continue; // keep irredundant
@@ -196,12 +174,11 @@ void Internal::reduce () {
 
   if (!propagate_out_of_order_units ()) goto DONE;
 
-  if (level) protect_reasons ();
   mark_satisfied_clauses_as_garbage ();
+  protect_reasons ();
   if (flush) mark_clauses_to_be_flushed ();
   else mark_useless_redundant_clauses_as_garbage ();
   garbage_collection ();
-  if (level) unprotect_reasons ();
 
   {
     int64_t delta = opts.reduceint * (stats.reductions + 1);
@@ -216,10 +193,12 @@ void Internal::reduce () {
   }
 
   if (flush) {
-    PHASE ("flush", stats.flush.count, "new flush increment %" PRId64 "", inc.flush);
+    PHASE ("flush", stats.flush.count,
+      "new flush increment %" PRId64 "", inc.flush);
     inc.flush *= opts.flushfactor;
     lim.flush = stats.conflicts + inc.flush;
-    PHASE ("flush", stats.flush.count, "new flush limit %" PRId64 "", lim.flush);
+    PHASE ("flush", stats.flush.count,
+      "new flush limit %" PRId64 "", lim.flush);
   }
 
   last.reduce.conflicts = stats.conflicts;
diff --git a/src/rephase.cpp b/src/rephase.cpp
index 548a3559..69511444 100644
--- a/src/rephase.cpp
+++ b/src/rephase.cpp
@@ -33,7 +33,7 @@ char Internal::rephase_original () {
   signed char val = opts.phase ? 1 : -1;        // original = initial
   PHASE ("rephase", stats.rephased.total,
     "switching to original phase %d", val);
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     phases.saved[idx] = val;
   return 'O';
 }
@@ -45,7 +45,7 @@ char Internal::rephase_inverted () {
   signed char val = opts.phase ? -1 : 1;        // original = -initial
   PHASE ("rephase", stats.rephased.total,
     "switching to inverted original phase %d", val);
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     phases.saved[idx] = val;
   return 'I';
 }
@@ -56,7 +56,7 @@ char Internal::rephase_flipping () {
   stats.rephased.flipped++;
   PHASE ("rephase", stats.rephased.total,
     "flipping all phases individually");
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     phases.saved[idx] *= -1;
   return 'F';
 }
@@ -69,7 +69,7 @@ char Internal::rephase_random () {
     "resetting all phases randomly");
   Random random (opts.seed);                    // global seed
   random += stats.rephased.random;              // different every time
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     phases.saved[idx] = random.generate_bool () ? -1 : 1;
   return '#';
 }
@@ -82,7 +82,7 @@ char Internal::rephase_best () {
   PHASE ("rephase", stats.rephased.total,
     "overwriting saved phases by best phases");
   signed char val;
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     if ((val = phases.best[idx]))
       phases.saved[idx] = val;
   return 'B';
diff --git a/src/report.cpp b/src/report.cpp
index a9f77033..31e23ea6 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -29,11 +29,12 @@ c  covered clause elimination
 d  decomposed binary implication graph and substituted equivalent literals
 2  removed duplicated binary clauses
 e  bounded variable elimination round
+^  variable elimination bound increased
 I  variable instantiation
 [  start of stable search phase
 ]  end of stable search phase
 {  start of unstable search phase
-j  end of unstable search phase
+}  end of unstable search phase
 P  preprocessing round (capital 'P')
 L  local search round
 *  start of solving without the need to restore clauses
@@ -221,6 +222,7 @@ void Internal::report (char type, int verbose) {
     case 'z': case 'f':           tout.cyan (true); break;
     case '-':                     tout.normal (); break;
     case '/':                     tout.yellow (true); break;
+    case 'a': case 'n':           tout.red (false); break;
     case '0': case '1': case '?':
     case 'i':                     tout.bold (); break;
     case 'L': case 'P':           tout.bold (); tout.underline (); break;
diff --git a/src/resources.cpp b/src/resources.cpp
index b21416d4..56b5ceb3 100644
--- a/src/resources.cpp
+++ b/src/resources.cpp
@@ -2,8 +2,9 @@
 
 /*------------------------------------------------------------------------*/
 
-// This is pretty Linux specific code for reporting resource usage.
-// TODO: port these functions to different OS.
+// This is pretty Linux specific code for resource usage and limits.
+
+// TODO: port these functions to different OS (Windows + MacOS).
 
 extern "C" {
 #include <sys/time.h>
@@ -48,10 +49,10 @@ double Internal::process_time () {
 
 // This seems to work on Linux (man page says since Linux 2.6.32).
 
-size_t maximum_resident_set_size () {
+uint64_t maximum_resident_set_size () {
   struct rusage u;
   if (getrusage (RUSAGE_SELF, &u)) return 0;
-  return ((size_t) u.ru_maxrss) << 10;
+  return ((uint64_t) u.ru_maxrss) << 10;
 }
 
 // Unfortunately 'getrusage' on Linux does not support current resident set
@@ -61,15 +62,139 @@ size_t maximum_resident_set_size () {
 // The code would still compile though (assuming 'sysconf' and
 // '_SC_PAGESIZE' are available).
 
-size_t current_resident_set_size () {
+uint64_t current_resident_set_size () {
   char path[40];
   sprintf (path, "/proc/%" PRId64 "/statm", (int64_t) getpid ());
   FILE * file = fopen (path, "r");
   if (!file) return 0;
-  int64_t dummy, rss;
-  int scanned = fscanf (file, "%" PRId64 " %" PRId64 "", &dummy, &rss);
+  uint64_t dummy, rss;
+  int scanned = fscanf (file, "%" PRIu64 " %" PRIu64 "", &dummy, &rss);
   fclose (file);
   return scanned == 2 ? rss * sysconf (_SC_PAGESIZE) : 0;
 }
 
+/*------------------------------------------------------------------------*/
+
+// Compiled in assumed default number of core.
+//
+static const int NUM_CORES = 4;
+
+// Try to obtain the number of cores.
+//
+int number_of_cores (Internal * internal)
+{
+#ifdef QUIET
+  (void) internal;
+#endif
+
+  bool amd, intel, res;
+
+  const int syscores = sysconf (_SC_NPROCESSORS_ONLN);
+  if (syscores > 0) MSG ("'sysconf' reports %d processors", syscores);
+  else MSG ("'sysconf' fails to determine number of online processors");
+
+  FILE * p = popen (
+               "grep '^core id' /proc/cpuinfo 2>/dev/null|sort|uniq|wc -l",
+               "r");
+  int coreids;
+  if (p) {
+    if (fscanf (p, "%d", &coreids) != 1) coreids = 0;
+    if (coreids > 0) MSG ("found %d core ids in '/proc/cpuinfo'", coreids);
+    else MSG ("failed to extract core ids from '/proc/cpuinfo'");
+    pclose (p);
+  } else coreids = 0;
+
+  p = popen (
+        "grep '^physical id' /proc/cpuinfo 2>/dev/null|sort|uniq|wc -l",
+        "r");
+  int physids;
+  if (p) {
+    if (fscanf (p, "%d", &physids) != 1) physids = 0;
+    if (physids > 0)
+         MSG ("found %d physical ids in '/proc/cpuinfo'", physids);
+    else MSG ("failed to extract physical ids from '/proc/cpuinfo'");
+    pclose (p);
+  } else physids = 0;
+
+  int procpuinfocores;
+  if (coreids > 0 && physids > 0 &&
+      (procpuinfocores = coreids * physids) > 0) {
+    MSG ("%d cores = %d core times %d physical ids in '/proc/cpuinfo'",
+         procpuinfocores, coreids, physids);
+  } else procpuinfocores = 0;
+
+  bool usesyscores = false, useprocpuinfo = false;
+
+  if (procpuinfocores > 0 && procpuinfocores == syscores) {
+    MSG ("'sysconf' and '/proc/cpuinfo' results match");
+    usesyscores = 1;
+  } else if (procpuinfocores > 0 && syscores <= 0) {
+    MSG ("only '/proc/cpuinfo' result valid");
+    useprocpuinfo = 1;
+  } else if (procpuinfocores <= 0 && syscores > 0) {
+    MSG ("only 'sysconf' result valid");
+    usesyscores = 1;
+  } else if (procpuinfocores > 0 && syscores > 0) {
+    intel = !system ("grep vendor /proc/cpuinfo 2>/dev/null|grep -q Intel");
+    if (intel) MSG ("found Intel as vendor in '/proc/cpuinfo'");
+    amd = !system ("grep vendor /proc/cpuinfo 2>/dev/null|grep -q AMD");
+    if (amd) MSG ("found AMD as vendor in '/proc/cpuinfo'");
+    assert (syscores > 0);
+    assert (procpuinfocores > 0);
+    assert (syscores != procpuinfocores);
+    if (amd) {
+      MSG ("trusting 'sysconf' on AMD");
+      usesyscores = true;
+    } else if (intel) {
+      MSG ("'sysconf' result off by a factor of %f on Intel",
+           syscores / (double) procpuinfocores);
+      MSG ("trusting '/proc/cpuinfo' on Intel");
+      useprocpuinfo = true;
+    }  else {
+      MSG ("trusting 'sysconf' on unknown vendor machine");
+      usesyscores = true;
+    }
+  }
+
+  if (useprocpuinfo) {
+    MSG (
+      "assuming cores = core * physical ids in '/proc/cpuinfo' = %d",
+      procpuinfocores);
+    res = procpuinfocores;
+  } else if (usesyscores) {
+    MSG (
+      "assuming cores = number of processors reported by 'sysconf' = %d",
+      syscores);
+    res = syscores;
+  } else {
+    MSG (
+      "falling back to compiled in default value of %d number of cores",
+      NUM_CORES);
+    res = NUM_CORES;
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static const unsigned MAX_GB = 7;
+
+uint64_t memory_limit (Internal * internal) {
+#ifdef QUIET
+  (void) internal;
+#endif
+  uint64_t res;
+  FILE * p = popen ("grep MemTotal /proc/meminfo", "r");
+  if (p && fscanf (p, "MemTotal: %" PRIu64 " kB", &res) == 1) {
+    MSG ("%" PRIu64 " KB total memory according to '/proc/meminfo'", res);
+    res <<= 10;
+  } else {
+    res = ((uint64_t) MAX_GB) << 30;;
+    MSG ("assuming compiled in memory limit of %u GB", MAX_GB);
+  }
+  if (p) pclose (p);
+  return res;
+}
+
 }
diff --git a/src/resources.hpp b/src/resources.hpp
index 0b32dfd8..e986cc7e 100644
--- a/src/resources.hpp
+++ b/src/resources.hpp
@@ -6,8 +6,11 @@ namespace CaDiCaL {
 double absolute_real_time ();
 double absolute_process_time ();
 
-size_t maximum_resident_set_size ();
-size_t current_resident_set_size ();
+uint64_t maximum_resident_set_size ();
+uint64_t current_resident_set_size ();
+
+int number_of_cores (Internal * internal = 0);
+uint64_t memory_limit (Internal * internal = 0);
 
 }
 
diff --git a/src/restore.cpp b/src/restore.cpp
index 5804941b..5779e97e 100644
--- a/src/restore.cpp
+++ b/src/restore.cpp
@@ -82,7 +82,7 @@ void External::restore_clauses () {
 
   PHASE ("restore", internal->stats.restorations,
     "starting with %zd tainted literals %.0f%%",
-    numtainted, percent (numtainted, 2*max_var));
+    numtainted, percent (numtainted, 2u*max_var));
 
   auto end_of_extension = extension.end ();
   auto p = extension.begin (), q = p;
@@ -193,7 +193,7 @@ void External::restore_clauses () {
 
   PHASE ("restore", internal->stats.restorations,
     "finishing with %zd tainted literals %.0f%%",
-    numtainted, percent (numtainted, 2*max_var));
+    numtainted, percent (numtainted, 2u*max_var));
 
   LOG ("extension stack clean");
   tainted.clear ();
diff --git a/src/score.cpp b/src/score.cpp
index 43e622f0..a9eea6ac 100644
--- a/src/score.cpp
+++ b/src/score.cpp
@@ -9,8 +9,8 @@ namespace CaDiCaL {
 void Internal::init_scores (int old_max_var, int new_max_var) {
   LOG ("initializing EVSIDS scores from %d to %d",
     old_max_var + 1, new_max_var);
-  for (int i = old_max_var + 1; i <= new_max_var; i++)
-    scores.push_back (i);
+  for (int i = old_max_var; i < new_max_var; i++)
+    scores.push_back (i + 1);
 }
 
 // Shuffle the EVSIDS heap.
@@ -39,9 +39,9 @@ void Internal::shuffle_scores () {
       shuffle.push_back (idx);
     }
   }
-  scinc = 0;
+  score_inc = 0;
   for (const auto & idx : shuffle) {
-    stab[idx] = scinc++;
+    stab[idx] = score_inc++;
     scores.push_back (idx);
   }
 }
diff --git a/src/solution.cpp b/src/solution.cpp
index 958a0d10..4041b651 100644
--- a/src/solution.cpp
+++ b/src/solution.cpp
@@ -15,12 +15,12 @@ void External::check_solution_on_learned_clause () {
   for (const auto & lit : internal->clause)
     if (sol (internal->externalize (lit)) > 0)
       return;
-  internal->fatal_message_start ();
+  fatal_message_start ();
   fputs ("learned clause unsatisfied by solution:\n", stderr);
   for (const auto & lit : internal->clause)
     fprintf (stderr, "%d ", lit);
   fputc ('0', stderr);
-  internal->fatal_message_end ();
+  fatal_message_end ();
 }
 
 void External::check_solution_on_shrunken_clause (Clause * c) {
@@ -28,11 +28,11 @@ void External::check_solution_on_shrunken_clause (Clause * c) {
   for (const auto & lit : *c)
     if (sol (internal->externalize (lit)) > 0)
       return;
-  internal->fatal_message_start ();
+  fatal_message_start ();
   for (const auto & lit : *c)
     fprintf (stderr, "%d ", lit);
   fputc ('0', stderr);
-  internal->fatal_message_end ();
+  fatal_message_end ();
 }
 
 void External::check_no_solution_after_learning_empty_clause () {
diff --git a/src/solver.cpp b/src/solver.cpp
index 68f94345..49bfa695 100644
--- a/src/solver.cpp
+++ b/src/solver.cpp
@@ -250,6 +250,10 @@ do { \
 #endif  // end of 'else' part of 'ifdef LOGGING'
 /*------------------------------------------------------------------------*/
 
+/*------------------------------------------------------------------------*/
+#ifndef NTRACING
+/*------------------------------------------------------------------------*/
+
 #define TRACE(...) \
 do { \
   if ((this == 0)) break; \
@@ -283,19 +287,31 @@ Solver::trace_api_call (const char * s0, const char * s1, int i2) const {
 
 /*------------------------------------------------------------------------*/
 
-// The global 'tracing_api' flag is used to ensure that only one solver
-// traces to a file.  Otherwise the method to use an environment variable to
-// point to the trace file is bogus, since those different solver instances
-// would all write to the same file producing garbage.  A more sophisticated
-// solution would use a different mechanism to tell the solver to which file
-// to trace to, but in our experience it is quite convenient to get traces
-// out of applications which use the solver as library by just setting an
-// environment variable without requiring to change any application code.
+// The global 'tracing_api_calls_through_environment_variable_method' flag
+// is used to ensure that only one solver traces to a file.  Otherwise the
+// method to use an environment variable to point to the trace file is
+// bogus, since those different solver instances would all write to the same
+// file producing garbage.  A more sophisticated solution would use a
+// different mechanism to tell the solver to which file to trace to, but in
+// our experience it is quite convenient to get traces out of applications
+// which use the solver as library by just setting an environment variable
+// without requiring to change any application code.
 //
 static bool tracing_api_calls_through_environment_variable_method;
 
+/*------------------------------------------------------------------------*/
+#else // NTRACING
+/*------------------------------------------------------------------------*/
+
+#define TRACE(...) do { } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif
+/*------------------------------------------------------------------------*/
+
 Solver::Solver () {
 
+#ifndef NTRACING
   const char * path = getenv ("CADICAL_API_TRACE");
   if (!path) path = getenv ("CADICALAPITRACE");
   if (path) {
@@ -312,14 +328,17 @@ Solver::Solver () {
     close_trace_api_file = false;
     trace_api_file = 0;
   }
+#endif
 
   _state = INITIALIZING;
   internal = new Internal ();
   TRACE ("init");
   external = new External (internal);
   STATE (CONFIGURING);
+#ifndef NTRACING
   if (tracing_api_calls_through_environment_variable_method)
     message ("tracing API calls to '%s'", path);
+#endif
 }
 
 Solver::~Solver () {
@@ -340,6 +359,7 @@ Solver::~Solver () {
   delete internal;
   delete external;
 
+#ifndef NTRACING
   if (close_trace_api_file) {
     close_trace_api_file = false;
     assert (trace_api_file);
@@ -347,6 +367,7 @@ Solver::~Solver () {
     fclose (trace_api_file);
     tracing_api_calls_through_environment_variable_method = false;
   }
+#endif
 
 #ifdef LOGGING
   //
@@ -387,6 +408,7 @@ void Solver::reserve (int min_max_var) {
 }
 
 /*------------------------------------------------------------------------*/
+#ifndef NTRACING
 
 void Solver::trace_api_calls (FILE * file) {
   LOG_API_CALL_BEGIN ("trace_api_calls");
@@ -401,12 +423,17 @@ void Solver::trace_api_calls (FILE * file) {
   trace_api_call ("init");
 }
 
+#endif
 /*------------------------------------------------------------------------*/
 
 bool Solver::is_valid_option (const char * name) {
   return Options::has (name);
 }
 
+bool Solver::is_preprocessing_option (const char * name) {
+  return Options::is_preprocessing_option (name);
+}
+
 bool Solver::is_valid_long_option (const char * arg) {
   string name;
   int tmp;
@@ -423,6 +450,7 @@ bool Solver::set (const char * arg, int val) {
   REQUIRE_VALID_STATE ();
   if (strcmp (arg, "log") &&
       strcmp (arg, "quiet") &&
+      strcmp (arg, "report") &&
       strcmp (arg, "verbose")) {
     REQUIRE (state () == CONFIGURING,
       "can only set option 'set (\"%s\", %d)' right after initialization",
@@ -471,7 +499,7 @@ bool Solver::is_valid_limit (const char * arg) {
 
 void Solver::prefix (const char * str) {
   LOG_API_CALL_BEGIN ("prefix", str);
-  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_OR_SOLVING_STATE ();
   internal->prefix = str;
   LOG_API_CALL_END ("prefix", str);
 }
@@ -481,12 +509,12 @@ bool Solver::is_valid_configuration (const char * name) {
 }
 
 bool Solver::configure (const char * name) {
-  LOG_API_CALL_BEGIN ("config", name);
+  LOG_API_CALL_BEGIN ("configure", name);
   REQUIRE_VALID_STATE ();
   REQUIRE (state () == CONFIGURING,
     "can only set configuration '%s' right after initialization", name);
-  bool res = Config::set (*this, name);
-  LOG_API_CALL_END ("config", name, res);
+  bool res = Config::set (internal->opts, name);
+  LOG_API_CALL_END ("configure", name, res);
   return res;
 }
 
@@ -512,13 +540,41 @@ void Solver::assume (int lit) {
   LOG_API_CALL_END ("assume", lit);
 }
 
+int Solver::lookahead () {
+  TRACE ("lookahead");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  int lit = external->lookahead ();
+  TRACE ("lookahead");
+  return lit;
+}
+
+Solver::CubesWithStatus Solver::generate_cubes (int depth) {
+  TRACE ("lookahead_cubes");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  auto cubes {external->generate_cubes (depth)};
+  TRACE ("lookahead_cubes");
+
+  CubesWithStatus cubes2;
+  cubes2.status = cubes.status;
+  cubes2.cubes = cubes.cubes;
+  return cubes2;
+}
+
+void Solver::reset_assumptions () {
+  TRACE ("reset_assumptions");
+  REQUIRE_VALID_STATE ();
+  transition_to_unknown_state ();
+  external->reset_assumptions ();
+  LOG_API_CALL_END ("reset_assumptions");
+}
+
 /*------------------------------------------------------------------------*/
 
-int Solver::call_external_solve_and_check_results () {
+int Solver::call_external_solve_and_check_results (bool preprocess_only) {
   transition_to_unknown_state ();
   assert (state () & READY);
   STATE (SOLVING);
-  int res = external->solve ();
+  const int res = external->solve (preprocess_only);
        if (res == 10) STATE (SATISFIED);
   else if (res == 20) STATE (UNSATISFIED);
   else                STATE (UNKNOWN);
@@ -547,24 +603,19 @@ int Solver::call_external_solve_and_check_results () {
 
 int Solver::solve () {
   TRACE ("solve");
-  REQUIRE_VALID_STATE ();
-  REQUIRE (state () != ADDING,
-    "clause incomplete (terminating zero not added)");
-  int res = call_external_solve_and_check_results ();
+  REQUIRE_READY_STATE ();
+  const int res = call_external_solve_and_check_results (false);
   LOG_API_CALL_RETURNS ("solve", res);
   return res;
 }
 
 int Solver::simplify (int rounds) {
   TRACE ("simplify", rounds);
-  REQUIRE_VALID_STATE ();
+  REQUIRE_READY_STATE ();
   REQUIRE (rounds >= 0,
     "negative number of simplification rounds '%d'", rounds);
-  REQUIRE (state () != ADDING,
-    "clause incomplete (terminating zero not added)");
-  internal->limit ("conflicts", 0);
   internal->limit ("preprocessing", rounds);
-  int res = call_external_solve_and_check_results ();
+  const int res = call_external_solve_and_check_results (true);
   LOG_API_CALL_RETURNS ("simplify", rounds, res);
   return res;
 }
@@ -602,6 +653,22 @@ int Solver::fixed (int lit) const {
   return res;
 }
 
+void Solver::phase (int lit) {
+  TRACE ("phase", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->phase (lit);
+  LOG_API_CALL_END ("phase", lit);
+}
+
+void Solver::unphase (int lit) {
+  TRACE ("unphase", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->unphase (lit);
+  LOG_API_CALL_END ("unphase", lit);
+}
+
 /*------------------------------------------------------------------------*/
 
 void Solver::terminate () {
@@ -638,6 +705,35 @@ void Solver::disconnect_terminator () {
   LOG_API_CALL_END ("disconnect_terminator");
 }
 
+/*------------------------------------------------------------------------*/
+
+void Solver::connect_learner (Learner * learner) {
+  LOG_API_CALL_BEGIN ("connect_learner");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (learner, "can not connect zero learner");
+#ifdef LOGGING
+  if (external->learner)
+    LOG ("connecting new learner (disconnecting previous one)");
+  else
+    LOG ("connecting new learner (no previous one)");
+#endif
+  external->learner = learner;
+  LOG_API_CALL_END ("connect_learner");
+}
+
+void Solver::disconnect_learner () {
+  LOG_API_CALL_BEGIN ("disconnect_learner");
+  REQUIRE_VALID_STATE ();
+#ifdef LOGGING
+    if (external->learner)
+      LOG ("disconnecting previous learner");
+    else
+      LOG ("ignoring to disconnect learner (no previous one)");
+#endif
+  external->learner = 0;
+  LOG_API_CALL_END ("disconnect_learner");
+}
+
 /*===== IPASIR END =======================================================*/
 
 int Solver::active () const {
@@ -814,17 +910,27 @@ void Solver::statistics () {
   if (state () == DELETING) return;
   TRACE ("stats");
   REQUIRE_VALID_OR_SOLVING_STATE ();
-  internal->print_stats ();
+  internal->print_statistics ();
   LOG_API_CALL_END ("stats");
 }
 
+void Solver::resources () {
+  if (state () == DELETING) return;
+  TRACE ("resources");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  internal->print_resource_usage ();
+  LOG_API_CALL_END ("resources");
+}
+
 /*------------------------------------------------------------------------*/
 
-const char * Solver::read_dimacs (File * file, int & vars, int strict) {
+const char * Solver::read_dimacs (File * file, int & vars, int strict,
+				  bool * incremental, vector<int> * cubes)
+{
   REQUIRE_VALID_STATE ();
   REQUIRE (state () == CONFIGURING,
     "can only read DIMACS file right after initialization");
-  Parser * parser = new Parser (this, file);
+  Parser * parser = new Parser (this, file, incremental, cubes);
   const char * err = parser->parse_dimacs (vars, strict);
   delete parser;
   return err;
@@ -861,13 +967,48 @@ Solver::read_dimacs (const char * path, int & vars, int strict) {
   return err;
 }
 
+const char *
+Solver::read_dimacs (FILE * external_file,
+                     const char * name, int & vars, int strict,
+		     bool & incremental, vector<int> & cubes) {
+  LOG_API_CALL_BEGIN ("read_dimacs", name);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only read DIMACS file right after initialization");
+  File * file = File::read (internal, external_file, name);
+  assert (file);
+  const char * err =
+    read_dimacs (file, vars, strict, &incremental, &cubes);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", name, err);
+  return err;
+}
+
+const char *
+Solver::read_dimacs (const char * path, int & vars, int strict,
+		     bool & incremental, vector<int> & cubes) {
+  LOG_API_CALL_BEGIN ("read_dimacs", path);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only read DIMACS file right after initialization");
+  File * file = File::read (internal, path);
+  if (!file)
+    return internal->error_message.init (
+             "failed to read DIMACS file '%s'", path);
+  const char * err =
+    read_dimacs (file, vars, strict, &incremental, &cubes);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", path, err);
+  return err;
+}
+
 const char * Solver::read_solution (const char * path) {
   LOG_API_CALL_BEGIN ("solution", path);
   REQUIRE_VALID_STATE ();
   File * file = File::read (internal, path);
   if (!file) return internal->error_message.init (
                       "failed to read solution file '%s'", path);
-  Parser * parser = new Parser (this, file);
+  Parser * parser = new Parser (this, file, 0, 0);
   const char * err = parser->parse_solution ();
   delete parser;
   delete file;
@@ -1062,10 +1203,15 @@ struct WitnessCopier : public WitnessIterator {
 };
 
 void Solver::copy (Solver & other) const {
+  REQUIRE_READY_STATE ();
+  REQUIRE (other.state () & CONFIGURING,
+    "target solver already modified");
+  internal->opts.copy (other.internal->opts);
   ClauseCopier clause_copier (other);
   traverse_clauses (clause_copier);
   WitnessCopier witness_copier (other.external);
   traverse_witnesses_forward (witness_copier);
+  external->copy_flags (*other.external);
 }
 
 /*------------------------------------------------------------------------*/
diff --git a/src/stats.cpp b/src/stats.cpp
index 8513f135..41c0d0cf 100644
--- a/src/stats.cpp
+++ b/src/stats.cpp
@@ -113,6 +113,7 @@ void Stats::print (Internal * internal) {
   PRT ("  probefailed:   %15" PRId64 "   %10.2f %%  per failed", stats.probefailed, percent (stats.probefailed, stats.failed));
   PRT ("  transredunits: %15" PRId64 "   %10.2f %%  per failed", stats.transredunits, percent (stats.transredunits, stats.failed));
   PRT ("  probingphases: %15" PRId64 "   %10.2f    interval", stats.probingphases, relative (stats.conflicts, stats.probingphases));
+  PRT ("  probesuccess:  %15" PRId64 "   %10.2f %%  phases", stats.probesuccess, percent (stats.probesuccess, stats.probingphases));
   PRT ("  probingrounds: %15" PRId64 "   %10.2f    per phase", stats.probingrounds, relative (stats.probingrounds, stats.probingphases));
   PRT ("  probed:        %15" PRId64 "   %10.2f    per failed", stats.probed, relative (stats.probed, stats.failed));
   PRT ("  hbrs:          %15" PRId64 "   %10.2f    per probed", stats.hbrs, relative (stats.hbrs, stats.probed));
@@ -261,17 +262,21 @@ void Stats::print (Internal * internal) {
 
   MSG ("");
   MSG ("%sseconds are measured in %s time for solving%s",
-    tout.magenta_code (), internal->opts.realtime ? "real" : "process", tout.normal_code ());
-
-  SECTION ("resources");
-
-  size_t m = maximum_resident_set_size ();
-  PRT ("total process time since initialization: %12.2f    seconds", internal->process_time ());
-  PRT ("total real time since initialization:    %12.2f    seconds", internal->real_time ());
-  PRT ("maximum resident set size of process:    %12.2f    MB", m/(double)(1l<<20));
+    tout.magenta_code (),
+      internal->opts.realtime ? "real" : "process",
+    tout.normal_code ());
 
 #endif // ifndef QUIET
+}
 
+void Internal::print_resource_usage () {
+#ifndef QUIET
+  SECTION ("resources");
+  uint64_t m = maximum_resident_set_size ();
+  MSG ("total process time since initialization: %12.2f    seconds", internal->process_time ());
+  MSG ("total real time since initialization:    %12.2f    seconds", internal->real_time ());
+  MSG ("maximum resident set size of process:    %12.2f    MB", m/(double)(1l<<20));
+#endif
 }
 
 /*------------------------------------------------------------------------*/
diff --git a/src/stats.hpp b/src/stats.hpp
index bae0c015..cb5c13e2 100644
--- a/src/stats.hpp
+++ b/src/stats.hpp
@@ -182,6 +182,7 @@ struct Stats {
   int64_t binaries;     // learned binary clauses
   int64_t probingphases;// number of scheduled probing phases
   int64_t probingrounds;// number of probing rounds
+  int64_t probesuccess; // number successful probing phases
   int64_t probed;       // number of probed literals
   int64_t failed;       // number of failed literals
   int64_t hyperunary;   // hyper unary resolved unit clauses
diff --git a/src/subsume.cpp b/src/subsume.cpp
index 85ca3a0f..38c620b2 100644
--- a/src/subsume.cpp
+++ b/src/subsume.cpp
@@ -6,11 +6,11 @@ namespace CaDiCaL {
 
 // This file implements a global forward subsumption algorithm, which is run
 // frequently during search.  It works both on original (irredundant)
-// clauses and on 'sticky' learned clauses which are small enough or have a
-// small enough glue to be otherwise kept forever.  See 'opts.keepsize' and
-// 'opts.keeglue', e.g., a redundant clause is not extended and thus kept if
-// its size is smaller equal to 'opts.keepsize' or its glue is smaller equal
-// than 'opts.keepsize').
+// clauses and on 'sticky' learned clauses which are likely to be kept.
+// This is abstracted away in the 'likely_to_be_kept_clause' function, which
+// implicitly relies on 'opts.reducetier1lgue' (glucose level of clauses
+// which are not reduced) as well as dynamically determined size and glucose
+// level ('lim.keptglue' and 'lim.keptsize') of clauses kept in 'reduce'.
 //
 // Note, that 'forward' means that the clause from which the subsumption
 // check is started is checked for being subsumed by other (smaller or equal
@@ -22,19 +22,19 @@ namespace CaDiCaL {
 // subsumption algorithm in our SATeLite preprocessor in the context of
 // finding extremal sets in data mining and his suggested improvements.
 
-// Our original 'SATeLite' subsumption algorithm (and in MiniSAT and
-// descendants) is based on backward subsumption.  It uses the observation
-// that only the occurrence list of one literal of a clause has to traversed
-// in order to find all potential clauses which are subsumed by the
-// candidate.  Thus the literal with the smallest number of occurrences is
-// used.  However, that scheme requires to connect all literals of surviving
-// clauses, while forward algorithms only need to connect one literal. On
-// the other hand forward checking requires to traverse the occurrence lists
-// of all literals of the candidate clause to find subsuming clauses.
-// During connecting the single literal (similar to the one-watch scheme by
-// Lintao Zhang) one can connect a literal with a minimal number of
-// occurrence so far, which implicitly also reduces future occurrence list
-// traversal time.
+// Our original subsumption algorithm in 'Quantor' and 'SATeLite' (and in
+// MiniSAT and descendants) is based on backward subsumption.  It uses the
+// observation that only the occurrence list of one literal of a clause has
+// to be traversed in order to find all potential clauses which are subsumed
+// by the candidate.  Thus the literal with the smallest number of
+// occurrences is used.  However, that scheme requires to connect all
+// literals of surviving clauses, while forward algorithms only need to
+// connect one literal. On the other hand forward checking requires to
+// traverse the occurrence lists of all literals of the candidate clause to
+// find subsuming clauses.  During connecting the single literal (similar to
+// the one-watch scheme by Lintao Zhang) one can connect a literal with a
+// minimal number of occurrence so far, which implicitly also reduces future
+// occurrence list traversal time.
 
 // Also the actual subsumption check is cheaper since during backward
 // checking the short subsuming candidate clause is marked and all the
@@ -59,7 +59,6 @@ namespace CaDiCaL {
 
 bool Internal::subsuming () {
 
-  if (!opts.simplify) return false;
   if (!opts.subsume && !opts.vivify) return false;
   if (!preprocessing && !opts.inprocessing) return false;
   if (preprocessing) assert (lim.preprocessing);
@@ -188,6 +187,8 @@ Internal::try_to_subsume_clause (Clause * c, vector<Clause *> & shrunken) {
 
   mark (c);     // signed!
 
+  Clause dummy; // Communicate binary subsuming clause.
+
   Clause * d = 0;
   int flipped = 0;
 
@@ -222,17 +223,17 @@ Internal::try_to_subsume_clause (Clause * c, vector<Clause *> & shrunken) {
         if (tmp < 0 && sign < 0) continue;
         if (tmp < 0) {
           if (sign < 0) continue;               // tautological resolvent
-          binary_subsuming.literals[0] = lit;
-          binary_subsuming.literals[1] = other;
+          dummy.literals[0] = lit;
+          dummy.literals[1] = other;
           flipped = other;
         } else {
-          binary_subsuming.literals[0] = sign*lit;
-          binary_subsuming.literals[1] = other;
+          dummy.literals[0] = sign*lit;
+          dummy.literals[1] = other;
           flipped = (sign < 0) ? -lit : INT_MIN;
         }
-        assert (binary_subsuming.size == 2);
-        assert (!binary_subsuming.redundant);
-        d = &binary_subsuming;
+        dummy.redundant = false;
+        dummy.size = 2;
+        d = &dummy;
         break;
       }
 
@@ -323,7 +324,8 @@ struct subsume_less_noccs {
 bool Internal::subsume_round () {
 
   if (!opts.subsume) return false;
-  if (unsat || terminating ()) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
   if (!stats.current.redundant && !stats.current.irredundant) return false;
 
   START_SIMPLIFIER (subsume, SUBSUME);
@@ -429,7 +431,7 @@ bool Internal::subsume_round () {
 
   for (const auto & s : schedule) {
 
-    if (terminating ()) break;
+    if (terminated_asynchronously ()) break;
     if (stats.subchecks >= check_limit) break;
 
     Clause * c = s.clause;
@@ -521,7 +523,8 @@ bool Internal::subsume_round () {
   }
 
   PHASE ("subsume-round", stats.subsumerounds,
-    "subsumed %" PRId64 " and strengthened %" PRId64 " out of %" PRId64 " clauses %.0f%%",
+    "subsumed %" PRId64 " and strengthened %" PRId64
+    " out of %" PRId64 " clauses %.0f%%",
     subsumed, strengthened, scheduled,
     percent (subsumed + strengthened, scheduled));
 
diff --git a/src/terminal.hpp b/src/terminal.hpp
index d217436f..62c3755b 100644
--- a/src/terminal.hpp
+++ b/src/terminal.hpp
@@ -68,6 +68,7 @@ class Terminal {
   const char * bright_yellow_code ()  { return MODIFY ("1;33"); }
   const char * green_code ()          { return MODIFY ("0;32"); }
   const char * red_code ()            { return MODIFY ("0;31"); }
+  const char * cyan_code ()           { return MODIFY ("0;96"); }
   const char * bright_red_code ()     { return MODIFY ("1;31"); }
   const char * normal_code ()         { return MODIFY ("0"   ); }
   const char * bold_code ()           { return MODIFY ("1"   ); }
diff --git a/src/ternary.cpp b/src/ternary.cpp
index dc9a8c36..111edc6e 100644
--- a/src/ternary.cpp
+++ b/src/ternary.cpp
@@ -244,7 +244,8 @@ bool Internal::ternary_round (int64_t & steps_limit, int64_t & htrs_limit) {
 
   // Try ternary resolution on all variables once.
   //
-  for (int idx = 1; !terminating () && idx <= max_var; idx++) {
+  for (auto idx : vars) {
+    if (terminated_asynchronously ()) break;
     if (steps_limit < 0) break;
     if (htrs_limit < 0) break;
     ternary_idx (idx, steps_limit, htrs_limit);
@@ -255,7 +256,7 @@ bool Internal::ternary_round (int64_t & steps_limit, int64_t & htrs_limit) {
   // sense to run another round of ternary resolution over those variables.
   //
   int remain = 0;
-  for (int idx = 1; idx <= max_var; idx++) {
+  for (auto idx : vars) {
     if (!active (idx)) continue;
     if (!flags (idx).ternary) continue;
     remain++;
@@ -278,10 +279,9 @@ bool Internal::ternary_round (int64_t & steps_limit, int64_t & htrs_limit) {
 
 bool Internal::ternary () {
 
-  assert (opts.simplify);
-
   if (!opts.ternary) return false;
-  if (unsat || terminating ()) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
 
   // No new ternary clauses added since last time?
   //
@@ -327,7 +327,7 @@ bool Internal::ternary () {
   bool completed = false;
 
   for (int round = 0;
-       !terminating () && round < opts.ternaryrounds;
+       !terminated_asynchronously () && round < opts.ternaryrounds;
        round++)
   {
     if (htrs_limit < 0) break;
diff --git a/src/tracer.hpp b/src/tracer.hpp
index e99e67b4..cc8f3039 100644
--- a/src/tracer.hpp
+++ b/src/tracer.hpp
@@ -8,12 +8,16 @@
 namespace CaDiCaL {
 
 class Tracer : public Observer {
+
   Internal * internal;
   File * file;
   bool binary;
+
+  int64_t added, deleted;
+
   void put_binary_zero ();
   void put_binary_lit (int external_lit);
-  int64_t added, deleted;
+
 public:
 
   Tracer (Internal *, File * file, bool binary); // own and delete 'file'
@@ -21,6 +25,7 @@ class Tracer : public Observer {
 
   void add_derived_clause (const vector<int> &);
   void delete_clause (const vector<int> &);
+
   bool closed ();
   void close ();
   void flush ();
diff --git a/src/transred.cpp b/src/transred.cpp
index b35ca0fd..b308a80e 100644
--- a/src/transred.cpp
+++ b/src/transred.cpp
@@ -5,16 +5,16 @@ namespace CaDiCaL {
 // Implement transitive reduction in the binary implication graph.  This is
 // important for hyper binary resolution, which has the risk to produce too
 // many hyper binary resolvents otherwise.  This algorithm only works on
-// binary clauses and is usually pretty fast, so we even do not limit it.
-// It will also find some failed literals (in the binary implication graph).
+// binary clauses and is usually pretty fast.  It will also find some failed
+// literals (in the binary implication graph).
 
 void Internal::transred () {
 
-  if (unsat || terminating ()) return;
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
   if (!stats.current.redundant && !stats.current.irredundant) return;
 
   assert (opts.transred);
-  assert (opts.simplify);
   assert (!level);
 
   START_SIMPLIFIER (transred, TRANSRED);
@@ -70,7 +70,11 @@ void Internal::transred () {
 
   int64_t propagations = 0, units = 0, removed = 0;
 
-  while (!unsat && i != end && !terminating () && propagations < limit) {
+  while (!unsat &&
+         i != end &&
+         !terminated_asynchronously () &&
+         propagations < limit)
+  {
     Clause * c = *i++;
 
     // A clause is a candidate for being transitive if it is binary, and not
diff --git a/src/util.cpp b/src/util.cpp
index 1cf644e6..f3b118c5 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -2,32 +2,75 @@
 
 namespace CaDiCaL {
 
-bool parse_int_str (const char * str, int & res) {
-  const char * p = str;
-  int sign, ch;
-  if ((ch = *p++) == '-') {
-    sign = -1;
-    if ((ch = *p++) == '0') return false;
-  } else sign = 1;
-  if (!isdigit (ch)) return false;
-  int64_t tmp = ch - '0';
-  while (isdigit (ch = *p++)) {
-    tmp = 10 * tmp + (ch - '0');
-    if (tmp > -(int64_t)INT_MIN) return false;
+/*------------------------------------------------------------------------*/
+
+bool parse_int_str(const char * val_str, int & val)
+{
+  if (!strcmp (val_str, "true")) val = 1;
+  else if (!strcmp (val_str, "false")) val = 0;
+  else {
+    const char * p = val_str;
+    int sign;
+
+    if (*p == '-') sign = -1, p++;
+    else sign = 1;
+
+    int ch;
+    if (!isdigit ((ch = *p++))) return false;
+
+    const int64_t bound = - (int64_t) INT_MIN;
+    int64_t mantissa = ch - '0';
+
+    while (isdigit (ch = *p++)) {
+      if (bound / 10 < mantissa) mantissa = bound;
+      else mantissa *= 10;
+      const int digit = ch - '0';
+      if (bound - digit < mantissa) mantissa = bound;
+      else mantissa += digit;
+    }
+
+    int exponent = 0;
+    if (ch  == 'e') {
+      while (isdigit ((ch = *p++)))
+        exponent = exponent ? 10 : ch - '0';
+      if (ch) return false;
+    } else if (ch) return false;
+
+    assert (exponent <= 10);
+    int64_t val64 = mantissa;
+    for (int i = 0; i < exponent; i++) val64 *= 10;
+
+    if (sign < 0) {
+      val64 = -val64;
+      if (val64 < INT_MIN) val64 = INT_MIN;
+    } else {
+      if (val64 > INT_MAX) val64 = INT_MAX;
+    }
+
+    assert (INT_MIN <= val64);
+    assert (val64 <= INT_MAX);
+
+    val = val64;
   }
-  if (ch) return false;
-  tmp *= sign;
-  if (tmp < (int64_t) INT_MIN) return false;
-  if (tmp > (int64_t) INT_MAX) return false;
-  res = tmp;
   return true;
 }
 
+/*------------------------------------------------------------------------*/
+
 bool has_suffix (const char * str, const char * suffix) {
   size_t k = strlen (str), l = strlen (suffix);
   return k > l && !strcmp (str + k - l, suffix);
 }
 
+bool has_prefix (const char * str, const char * prefix) {
+  for (const char * p = str, * q = prefix; *q; q++, p++)
+    if (*q != *p)
+      return false;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
 bool is_color_option (const char * arg) {
   return !strcmp (arg, "--color") ||
          !strcmp (arg, "--colors") ||
diff --git a/src/util.hpp b/src/util.hpp
index b5b9c461..1b5c0341 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -18,8 +18,23 @@ inline unsigned bign (int lit) { return 1 + (lit < 0); }
 
 /*------------------------------------------------------------------------*/
 
-bool parse_int_str (const char * str, int &);
 bool has_suffix (const char * str, const char * suffix);
+bool has_prefix (const char * str, const char * prefix);
+
+/*------------------------------------------------------------------------*/
+
+// Parse integer string in the form of
+//
+//   true
+//   false
+//   [-]<mantissa>[e<exponent>]
+//
+// and in the latter case '<val>' has to be within [-INT_MAX,INT_MAX].
+//
+// The function returns true if parsing is successful and then also sets
+// the second argument to the parsed value.
+
+bool parse_int_str (const char * str, int &);
 
 /*------------------------------------------------------------------------*/
 
@@ -28,6 +43,21 @@ inline bool is_power_of_two (unsigned n) { return n && !(n & (n-1)); }
 inline bool
 contained (int64_t c, int64_t l, int64_t u) { return l <= c && c <= u; }
 
+inline bool aligned (size_t n, size_t alignment) {
+  assert (is_power_of_two (alignment));
+  const size_t mask = alignment - 1;
+  return !(n & mask);
+}
+
+inline size_t align (size_t n, size_t alignment) {
+  size_t res = n;
+  assert (is_power_of_two (alignment));
+  const size_t mask = alignment - 1;
+  if (res & mask) res = (res | mask) + 1;
+  assert (aligned (res, alignment));
+  return res;
+}
+
 /*------------------------------------------------------------------------*/
 
 inline bool parity (unsigned a) {
diff --git a/src/var.cpp b/src/var.cpp
index 679c0c73..cc27258b 100644
--- a/src/var.cpp
+++ b/src/var.cpp
@@ -4,14 +4,14 @@ namespace CaDiCaL {
 
 void Internal::reset_subsume_bits () {
   LOG ("marking all variables as not subsume");
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     flags (idx).subsume = false;
 }
 
 void Internal::check_var_stats () {
 #ifndef NDEBUG
-  int fixed = 0, eliminated = 0, substituted = 0, pure = 0, unused = 0;
-  for (int idx = 1; idx <= max_var; idx++) {
+  int64_t fixed = 0, eliminated = 0, substituted = 0, pure = 0, unused = 0;
+  for (auto idx : vars) {
     Flags & f = flags (idx);
     if (f.active ()) continue;
     if (f.fixed ()) fixed++;
@@ -24,7 +24,7 @@ void Internal::check_var_stats () {
   assert (stats.now.eliminated == eliminated);
   assert (stats.now.substituted == substituted);
   assert (stats.now.pure == pure);
-  int inactive = unused + fixed + eliminated + substituted + pure;
+  int64_t inactive = unused + fixed + eliminated + substituted + pure;
   assert (stats.inactive == inactive);
   assert (max_var == stats.active + stats.inactive);
 #endif
diff --git a/src/var.hpp b/src/var.hpp
index 447dfc09..2a666e52 100644
--- a/src/var.hpp
+++ b/src/var.hpp
@@ -14,13 +14,7 @@ struct Var {
 
   int level;         // decision level
   int trail;         // trail height at assignment
-
-  union {
-
-    Clause * reason; // implication graph edge during search
-    int parent;      // implication graph parent during probing
-
-  };
+  Clause * reason;   // implication graph edge during search
 };
 
 }
diff --git a/src/version.cpp b/src/version.cpp
index 96d167e9..7db0994f 100644
--- a/src/version.cpp
+++ b/src/version.cpp
@@ -5,8 +5,10 @@
 // defining '-DNBUILD'.  Then we try to guess part of the configuration.
 
 #ifndef NBUILD
+#if __has_include(<build.hpp>)
 #include <build.hpp>
-#endif
+#endif // __has_include
+#endif // NBUILD
 
 /*------------------------------------------------------------------------*/
 
@@ -16,14 +18,18 @@
 // the file '../VERSION' with '../scripts/update-version.sh'.  The standard
 // build process relies on 'VERSION' to be defined in 'build.hpp'.
 
-#  define VERSION "1.2.1"
+#ifndef NBUILD
+#ifndef VERSION
+#  define VERSION "sc2020"
+#endif // NBUILD
+#endif // VERSION
 
 /*------------------------------------------------------------------------*/
 
 // The copyright of the code is here.
 
 static const char * COPYRIGHT =
-"Copyright (c) 2016-2019 Armin Biere, JKU Linz"
+"Copyright (c) 2016-2020 Armin Biere, JKU Linz"
 ;
 
 /*------------------------------------------------------------------------*/
@@ -67,7 +73,7 @@ static const char * COPYRIGHT =
 // Build Time and operating system.
 //
 #ifndef DATE
-#  define DATE __DATE__ __TIME__
+#  define DATE __DATE__ " " __TIME__
 #endif
 
 /*------------------------------------------------------------------------*/
diff --git a/src/vivify.cpp b/src/vivify.cpp
index 6e00ae0b..351b88b7 100644
--- a/src/vivify.cpp
+++ b/src/vivify.cpp
@@ -113,7 +113,6 @@ bool Internal::vivify_propagate () {
         if (w.clause == ignore) continue;
         literal_iterator lits = w.clause->begin ();
         const int other = lits[0]^lits[1]^lit;
-        lits[0] = other, lits[1] = lit;
         const signed char u = val (other);
         if (u > 0) j[-1].blit = other;
         else {
@@ -133,10 +132,10 @@ bool Internal::vivify_propagate () {
           }
           w.clause->pos = k - lits;
           assert (lits + 2 <= k), assert (k <= w.clause->end ());
-          if (v > 0) {
-            j[-1].blit = r;
-          } else if (!v) {
+          if (v > 0) j[-1].blit = r;
+          else if (!v) {
             LOG (w.clause, "unwatch %d in", r);
+            lits[0] = other;
             lits[1] = r;
             *k = lit;
             watch_literal (r, lit, w.clause);
@@ -870,7 +869,8 @@ void Internal::vivify_clause (Vivifier & vivifier, Clause * c) {
 
 void Internal::vivify_round (bool redundant_mode, int64_t propagation_limit) {
 
-  if (unsat || terminating ()) return;
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
 
   PHASE ("vivify", stats.vivifications,
     "starting %s vivification round propagation limit %" PRId64 "",
@@ -878,7 +878,7 @@ void Internal::vivify_round (bool redundant_mode, int64_t propagation_limit) {
 
   // Disconnect all watches since we sort literals within clauses.
   //
-  if (watching ()) disconnect_watches ();
+  if (watching ()) clear_watches ();
 
   // Count the number of occurrences of literals in all clauses,
   // particularly binary clauses, which are usually responsible
@@ -971,7 +971,7 @@ void Internal::vivify_round (bool redundant_mode, int64_t propagation_limit) {
   }
 
   while (!unsat &&
-         !terminating () &&
+         !terminated_asynchronously () &&
          !vivifier.schedule.empty () &&
          stats.propagations.vivify < limit) {
     Clause * c = vivifier.schedule.back ();              // Next candidate.
@@ -994,8 +994,8 @@ void Internal::vivify_round (bool redundant_mode, int64_t propagation_limit) {
     //
     if (still_need_to_be_vivified)
       PHASE ("vivify", stats.vivifications,
-        "still need to vivify %" PRId64 " clauses %.02f%% of %" PRId64 " scheduled",
-        still_need_to_be_vivified,
+        "still need to vivify %" PRId64 " clauses %.02f%% of %" PRId64
+	" scheduled", still_need_to_be_vivified,
         percent (still_need_to_be_vivified, scheduled),
         scheduled);
     else {
@@ -1008,7 +1008,7 @@ void Internal::vivify_round (bool redundant_mode, int64_t propagation_limit) {
     vivifier.erase ();          // Reclaim  memory early.
   }
 
-  disconnect_watches ();
+  clear_watches ();
   connect_watches ();
 
   if (!unsat) {
@@ -1061,11 +1061,11 @@ void Internal::vivify_round (bool redundant_mode, int64_t propagation_limit) {
 
 void Internal::vivify () {
 
-  if (unsat || terminating ()) return;
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
   if (!stats.current.irredundant) return;
 
   assert (opts.vivify);
-  assert (opts.simplify);
   assert (!level);
 
   START_SIMPLIFIER (vivify, VIVIFY);
diff --git a/src/walk.cpp b/src/walk.cpp
index 3c7e9a62..571351e9 100644
--- a/src/walk.cpp
+++ b/src/walk.cpp
@@ -473,7 +473,7 @@ int Internal::walk_round (int64_t limit, bool prev) {
 
   if (!failed) {
 
-    for (int idx = 1; idx <= max_var; idx++) {
+    for (auto idx : vars) {
       if (!active (idx)) {
         LOG ("skipping inactive variable %d", idx);
         continue;
@@ -574,7 +574,7 @@ int Internal::walk_round (int64_t limit, bool prev) {
     walk_save_minimum (walker);
 
     int64_t flips = 0, minimum = broken;
-    while (!terminating () &&
+    while (!terminated_asynchronously () &&
            !walker.broken.empty () &&
            walker.propagations < walker.limit) {
       flips++;
@@ -633,7 +633,7 @@ int Internal::walk_round (int64_t limit, bool prev) {
 
   copy_phases (phases.prev);
 
-  for (int idx = 1; idx <= max_var; idx++)
+  for (auto idx : vars)
     if (active (idx))
       vals[idx] = vals[-idx] = 0;
 
diff --git a/src/watch.cpp b/src/watch.cpp
index 276573fd..158b9da3 100644
--- a/src/watch.cpp
+++ b/src/watch.cpp
@@ -10,9 +10,8 @@ void Internal::init_watches () {
 }
 
 void Internal::clear_watches () {
-  for (int idx = 1; idx <= max_var; idx++)
-    for (int sign = -1; sign <= 1; sign += 2)
-      watches (sign * idx).clear ();
+  for (auto lit : lits)
+    watches (lit).clear ();
 }
 
 void Internal::reset_watches () {
@@ -75,38 +74,27 @@ void Internal::sort_watches () {
   assert (watching ());
   LOG ("sorting watches");
   Watches saved;
-  for (int idx = 1; idx <= max_var; idx++) {
-    for (int sign = -1; sign <= 1; sign += 2) {
+  for (auto lit : lits) {
+    Watches & ws = watches (lit);
 
-      const int lit = sign * idx;
-      Watches & ws = watches (lit);
+    const const_watch_iterator end = ws.end ();
+    watch_iterator j = ws.begin ();
+    const_watch_iterator i;
 
-      const const_watch_iterator end = ws.end ();
-      watch_iterator j = ws.begin ();
-      const_watch_iterator i;
+    assert (saved.empty ());
 
-      assert (saved.empty ());
-
-      for (i = j; i != end; i++) {
-        const Watch w = *i;
-        if (w.binary ()) *j++ = w;
-        else saved.push_back (w);
-      }
-      ws.resize (j - ws.begin ());
+    for (i = j; i != end; i++) {
+      const Watch w = *i;
+      if (w.binary ()) *j++ = w;
+      else saved.push_back (w);
+    }
+    ws.resize (j - ws.begin ());
 
-      for (const auto & w : saved)
-        ws.push_back (w);
+    for (const auto & w : saved)
+      ws.push_back (w);
 
-      saved.clear ();
-    }
+    saved.clear ();
   }
 }
 
-void Internal::disconnect_watches () {
-  LOG ("disconnecting watches");
-  for (int idx = 1; idx <= max_var; idx++)
-    for (int sign = -1; sign <= 1; sign += 2)
-      watches (sign * idx).clear ();
-}
-
 }
diff --git a/test/api/cipasir.c b/test/api/cipasir.c
new file mode 100644
index 00000000..fe145395
--- /dev/null
+++ b/test/api/cipasir.c
@@ -0,0 +1,95 @@
+#include "../../src/ipasir.h"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+
+static const int n = 8;
+
+static int ph (int p, int h) {
+  assert (0 <= p), assert (p < n + 1);
+  assert (0 <= h), assert (h < n);
+  return 1 + h * (n+1) + p;
+}
+
+// Construct a pigeon hole formula for 'n+1' pigeons in 'n' holes.
+//
+static void formula (void *solver)
+{
+  for (int h = 0; h < n; h++)
+    for (int p1 = 0; p1 < n + 1; p1++)
+      for (int p2 = p1 + 1; p2 < n + 1; p2++)
+	ipasir_add (solver, -ph (p1, h)),
+	ipasir_add (solver, -ph (p2, h)),
+	ipasir_add (solver, 0);
+
+  for (int p = 0; p < n + 1; p++) {
+    for (int h = 0; h < n; h++)
+      ipasir_add (solver, ph (p, h));
+    ipasir_add (solver, 0);
+  }
+}
+
+typedef struct learner learner;
+
+struct learner {
+  void * solver;
+  unsigned learned;
+};
+
+static void learn (void * ptr, int * clause) {
+  learner * learner = ptr;
+  for (const int * p = clause; *p; p++)
+    ipasir_add (learner->solver, *p);
+  ipasir_add (learner->solver, 0);
+  learner->learned++;
+}
+
+static int terminator (void * ptr) { return * (int*) ptr; }
+
+static int terminate;
+
+static void (*saved)(int);
+
+static void handler (int sig) {
+  assert (sig == SIGALRM);
+  signal (SIGALRM, saved);
+  terminate = 1;
+}
+
+static void * solvers[2];
+static learner learners[2];
+
+int main () {
+  printf ("signature '%s'\n", ipasir_signature ());
+  for (int i = 0; i < 2; i++) {
+    learners[i].solver = solvers[i] = ipasir_init ();
+    ipasir_set_learn (solvers[i], learners + !i, 3, learn);
+    formula (solvers[i]);
+  }
+  unsigned round = 0;
+  int active = 0;
+  int res = 0;
+  for (;;) {
+    printf ("round %d active %d imported %u\n",
+            ++round, active, learners[active].learned);
+    fflush (stdout);
+    saved = signal (SIGALRM, handler);
+    ualarm (2e4, 0);
+    ipasir_set_terminate (solvers[active], &terminate, terminator);
+    res = ipasir_solve (solvers[active]);
+    if (res) break;
+    terminate = 0;
+    active = !active;
+  }
+  for (int i = 0; i < 2; i++)
+    ipasir_release (solvers[i]);
+  for (int i = 0; i < 2; i++)
+    printf ("solver[%d] imported %u clauses\n", i, learners[i].learned);
+  return 0;
+}
diff --git a/test/api/learn.cpp b/test/api/learn.cpp
new file mode 100644
index 00000000..f856d6dc
--- /dev/null
+++ b/test/api/learn.cpp
@@ -0,0 +1,58 @@
+#include "../../src/cadical.hpp"
+
+#include <iostream>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+extern "C" {
+#include <assert.h>
+}
+
+class Wrapper : CaDiCaL::Learner {
+  CaDiCaL::Solver * solver;
+  std::vector<int> clause;
+public:
+  unsigned clauses;
+  Wrapper (CaDiCaL::Solver * s) : solver (s), clauses (0) { solver->connect_learner (this); }
+  ~Wrapper () { solver->disconnect_learner (); }
+  bool learning (int size) { (void) size; return true; }
+  void learn (int lit) {
+    if (lit) clause.push_back (lit);
+    else {
+      std::cout << "solver[" << ((void*) solver) << "] imported clause of size "
+                << clause.size () << ':';
+      for (auto lit : clause)
+	std::cout << ' ' << lit;
+      std::cout << std::endl << std::flush;
+      clause.clear ();
+      clauses++;
+    }
+  }
+};
+
+static void formula (CaDiCaL::Solver & solver) {
+  for (int r = -1; r < 2; r += 2)
+    for (int s = -1; s < 2; s += 2)
+      for (int t = -1; t < 2; t += 2)
+	solver.add (r * 1), solver.add (s * 2), solver.add (t * 3),
+	solver.add (0);
+}
+
+int main () {
+  CaDiCaL::Solver ping, pong;
+  ping.set ("log", 1), pong.set ("log", 1);
+  Wrapper wing (&ping), wong (&pong);
+  formula (ping), formula (pong);
+  int a = ping.solve ();
+  std::cout << "ping returns " << a << std::endl;
+  std::cout << "wong imported " << wing.clauses << " clauses" << std::endl;
+  int b = pong.solve ();
+  std::cout << "pong returns " << b << std::endl;
+  std::cout << "wing imported " << wing.clauses << " clauses" << std::endl;
+  assert (a == b), assert (a == 20);
+  assert (wing.clauses == wong.clauses);
+  assert (wing.clauses > 3);
+  return 0;
+}
diff --git a/test/api/run.sh b/test/api/run.sh
index 5b245d1c..406a54b9 100755
--- a/test/api/run.sh
+++ b/test/api/run.sh
@@ -106,9 +106,12 @@ run morenmore
 run ctest
 run example
 run terminate
+run learn
 run cfreeze
 run traverse
-run apitrace
+run cipasir
+
+[ "`grep DNTRACING $makefile`" = "" ] && run apitrace
 
 #--------------------------------------------------------------------------#
 
diff --git a/test/icnf/empty.icnf b/test/icnf/empty.icnf
new file mode 100644
index 00000000..a2c9f087
--- /dev/null
+++ b/test/icnf/empty.icnf
@@ -0,0 +1 @@
+p inccnf
diff --git a/test/icnf/false.icnf b/test/icnf/false.icnf
new file mode 100644
index 00000000..d3fb3770
--- /dev/null
+++ b/test/icnf/false.icnf
@@ -0,0 +1,2 @@
+p inccnf
+0
diff --git a/test/icnf/run.sh b/test/icnf/run.sh
new file mode 100755
index 00000000..be0ce170
--- /dev/null
+++ b/test/icnf/run.sh
@@ -0,0 +1,87 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+die () {
+  echo "${HIDE}test/icnf/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  exit 1
+}
+
+msg () {
+  echo "${HIDE}test/icnf/run.sh:${NORMAL} $*"
+}
+
+for dir in . .. ../..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+[ -d ../test -a -d ../test/icnf ] || \
+die "needs to be called from a top-level sub-directory of CaDiCaL"
+
+[ x"$CADICALBUILD" = x ] && CADICALBUILD="../build"
+
+[ -x "$CADICALBUILD/cadical" ] || \
+  die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
+
+echo -n "$HILITE"
+echo "---------------------------------------------------------"
+echo "ICNF testing in '$CADICALBUILD'" 
+echo "---------------------------------------------------------"
+echo -n "$NORMAL"
+
+make -C $CADICALBUILD
+res=$?
+[ $res = 0 ] || exit $res
+
+#--------------------------------------------------------------------------#
+
+solver="$CADICALBUILD/cadical"
+
+#--------------------------------------------------------------------------#
+
+ok=0
+failed=0
+
+run () {
+  msg "running ICNF tests ${HILITE}'$1'${NORMAL}"
+  prefix=$CADICALBUILD/test-icnf
+  icnf=../test/icnf/$1.icnf
+  log=$prefix-$1.log
+  err=$prefix-$1.err
+  opts="$icnf --check"
+  opts="$icnf"
+  echo "$solver \\"
+  echo "$opts"
+  echo -n "# $2 ..."
+  "$solver" $opts 1>$log 2>$err
+  res=$?
+  if [ ! $res = $2 ] 
+  then
+    echo " ${BAD}FAILED${NORMAL} (actual exit code $res)"
+    failed=`expr $failed + 1`
+  else
+    echo " ${GOOD}ok${NORMAL} (exit code '$res' as expected)"
+    ok=`expr $ok + 1`
+  fi
+}
+
+run empty 10
+run false 20
+run unit1 20
+run unit2 10
+run two1 20
+run two2 10
+
+#--------------------------------------------------------------------------#
+
+[ $ok -gt 0 ] && OK="$GOOD"
+[ $failed -gt 0 ] && FAILED="$BAD"
+
+msg "${HILITE}ICNF testing results:${NORMAL} ${OK}$ok ok${NORMAL}, ${FAILED}$failed failed${NORMAL}"
+
+exit $failed
diff --git a/test/icnf/two1.icnf b/test/icnf/two1.icnf
new file mode 100644
index 00000000..e45ae580
--- /dev/null
+++ b/test/icnf/two1.icnf
@@ -0,0 +1,7 @@
+p inccnf
+1 2 3 0
+-1 -2 3 0
+1 2 -3 0
+-1 -2 -3 0
+a 1 2 0
+a -1 -2 0
diff --git a/test/icnf/two2.icnf b/test/icnf/two2.icnf
new file mode 100644
index 00000000..c03414c0
--- /dev/null
+++ b/test/icnf/two2.icnf
@@ -0,0 +1,7 @@
+p inccnf
+1 2 3 0
+-1 -2 3 0
+1 2 -3 0
+-1 -2 -3 0
+a 1 2 0
+a -1 2 0
diff --git a/test/icnf/unit1.icnf b/test/icnf/unit1.icnf
new file mode 100644
index 00000000..df8ff929
--- /dev/null
+++ b/test/icnf/unit1.icnf
@@ -0,0 +1,3 @@
+p inccnf
+1 0
+a -1 0
diff --git a/test/icnf/unit2.icnf b/test/icnf/unit2.icnf
new file mode 100644
index 00000000..3d550bda
--- /dev/null
+++ b/test/icnf/unit2.icnf
@@ -0,0 +1,3 @@
+p inccnf
+1 0
+a 1 0
diff --git a/test/makefile b/test/makefile
index b45d0634..1c46862b 100644
--- a/test/makefile
+++ b/test/makefile
@@ -1,12 +1,14 @@
-test: usage trace api cnf mbt
+test: usage trace api cnf icnf mbt
 api:
 	@api/run.sh
 cnf:
 	@cnf/run.sh
+icnf:
+	@icnf/run.sh
 mbt:
 	@mbt/run.sh
 trace:
 	@trace/run.sh
 usage:
 	@usage/run.sh
-.PHONY: test api cnf mbt trace usage
+.PHONY: test api cnf icnf mbt trace usage
diff --git a/test/trace/reg0053.trace b/test/trace/reg0053.trace
new file mode 100644
index 00000000..8acf01ef
--- /dev/null
+++ b/test/trace/reg0053.trace
@@ -0,0 +1,3 @@
+0 init
+1 set lucky 0
+2 lookahead 0
diff --git a/test/trace/reg0054.trace b/test/trace/reg0054.trace
new file mode 100644
index 00000000..da9bd655
--- /dev/null
+++ b/test/trace/reg0054.trace
@@ -0,0 +1,5 @@
+0 init
+1 add 1
+2 add 2
+3 add 0
+4 lookahead 0
diff --git a/test/trace/reg0055.trace b/test/trace/reg0055.trace
new file mode 100644
index 00000000..80ec7aea
--- /dev/null
+++ b/test/trace/reg0055.trace
@@ -0,0 +1,14 @@
+0 init
+1 add -1
+2 add 2
+3 add 0
+4 add -2
+5 add -1
+6 add 0
+7 add -2
+8 add 1
+9 add 0
+10 add 1
+11 add 2
+12 add 0
+13 lookahead 0
diff --git a/test/usage/relaxed-header.cnf b/test/usage/relaxed-header.cnf
new file mode 100644
index 00000000..c5947ada
--- /dev/null
+++ b/test/usage/relaxed-header.cnf
@@ -0,0 +1,5 @@
+p   cnf   	1		  3   
+	1  	0	
+	-1  0
+  1
+0
diff --git a/test/usage/run.sh b/test/usage/run.sh
index c417ef19..32535873 100755
--- a/test/usage/run.sh
+++ b/test/usage/run.sh
@@ -89,12 +89,18 @@ then
   run 10 -q ../test/cnf/empty.cnf
 fi
 
+run 1 ../test/usage/missing-clause.cnf
+run 1 ../test/usage/variable-too-large.cnf
+run 1 --strict relaxed-header.cnf
+
 for option in "-f" "--force" "--force=1" "--force=true"
 do
   run 10 $option ../test/usage/missing-clause.cnf
   run 10 $option ../test/usage/variable-too-large.cnf
 done
 
+run 20 ../test/usage/relaxed-header.cnf
+
 # TODO:  still need to add test cases for these:
 
 for option in -O1 -O2 -O3

From 0b7a2b5764f845cff0b81ec16ebac20cb5cc138c Mon Sep 17 00:00:00 2001
From: Armin Biere <biere@jku.at>
Date: Thu, 11 Jun 2020 11:43:16 +0200
Subject: [PATCH 2/2] ports & fixed two issues

fixed gcc9, vc++2019, and cygwin issues (also colored script output)
./configure --check --quiet fix (was not tested by ./scripts/build-...)
fixed write_dimacs to call restore_clauses
---
 VERSION                                      |   2 +-
 configure                                    |   4 +-
 scripts/build-and-test-all-configurations.sh |   4 +
 scripts/colors.sh                            |  23 ++-
 src/profile.cpp                              |  11 +-
 src/profile.hpp                              | 144 ++++++++++---------
 src/random.hpp                               |   5 +
 src/solver.cpp                               |   7 +-
 src/version.cpp                              |   2 +-
 src/vivify.cpp                               |   6 +-
 test/api/run.sh                              |  20 +--
 test/cnf/run.sh                              |  72 +++++-----
 test/icnf/run.sh                             |  24 ++--
 test/mbt/run.sh                              |  16 +--
 test/trace/run.sh                            |  22 +--
 test/usage/run.sh                            |  22 +--
 16 files changed, 208 insertions(+), 176 deletions(-)
 mode change 100755 => 100644 scripts/colors.sh

diff --git a/VERSION b/VERSION
index 6582e891..f0bb29e7 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-sc2020
+1.3.0
diff --git a/configure b/configure
index c45a7b87..a4f8421e 100755
--- a/configure
+++ b/configure
@@ -51,12 +51,12 @@ die () {
   else
     checklog=""
   fi
-  echo "${BOLD}configure:${NORMAL} ${BAD}error:${NORMAL} $*${checklog}"
+  cecho "${BOLD}configure:${NORMAL} ${BAD}error:${NORMAL} $*${checklog}"
   exit 1
 }
 
 msg () {
-  echo "${BOLD}configure:${NORMAL} $*"
+  cecho "${BOLD}configure:${NORMAL} $*"
 }
 
 # if we can find the 'color.sh' script source it and overwrite color codes
diff --git a/scripts/build-and-test-all-configurations.sh b/scripts/build-and-test-all-configurations.sh
index 6dc0e594..d1e0596f 100755
--- a/scripts/build-and-test-all-configurations.sh
+++ b/scripts/build-and-test-all-configurations.sh
@@ -92,12 +92,16 @@ run -l -p
 # ('-g' can not be combined '-c')
 
 run -c -l
+run -c -q
 run -g -l
+run -g -q
 
 # the same pairs but now with pedantic compilation
 
 run -c -l -p
+run -c -q -p
 run -g -l -p
+run -g -q -p
 
 # finally check that these also work to some extend
 
diff --git a/scripts/colors.sh b/scripts/colors.sh
old mode 100755
new mode 100644
index 15f1817f..d65b919e
--- a/scripts/colors.sh
+++ b/scripts/colors.sh
@@ -1,13 +1,20 @@
 # Use colors if '<stdin>' is connected to a terminal.
 
+color_echo_options=""
+
 if [ -t 1 ]
 then
-  BAD="\033[1;31m"	# bright red
-  HILITE="\033[32m"	# normal green
-  GOOD="\033[1;32m"	# bright green
-  HIDE="\033[34m"	# cyan
-  BOLD="\033[1m"        # bold color
-  NORMAL="\033[0m"	# normal color
+  BAD="\033[1;31m"  # bright red
+  HILITE="\033[32m" # normal green
+  GOOD="\033[1;32m" # bright green
+  HIDE="\033[34m"   # cyan
+  BOLD="\033[1m"    # bold color
+  NORMAL="\033[0m"  # normal color
+
+  if [ x"`echo -e 2>/dev/null`" = x ]
+  then
+    color_echo_options=" -e"
+  fi
 else
   BAD=""
   HILITE=""
@@ -16,3 +23,7 @@ else
   BOLD=""
   NORMAL=""
 fi
+
+cecho () {
+  echo$color_echo_options $*
+}
diff --git a/src/profile.cpp b/src/profile.cpp
index bbb9a193..9346b0da 100644
--- a/src/profile.cpp
+++ b/src/profile.cpp
@@ -67,12 +67,13 @@ void Internal::print_profile () {
 #define PROFILE(NAME,LEVEL) \
 do { \
   if (LEVEL > opts.profile) break; \
-  if (&profiles.NAME == &profiles.solve) break; \
+  Profile * p = &profiles.NAME; \
+  if (p == &profiles.solve) break; \
   if (!profiles.NAME.value && \
-      &profiles.NAME != &profiles.parse && \
-      &profiles.NAME != &profiles.search && \
-      &profiles.NAME != &profiles.simplify) break; \
-  profs[n++] = &profiles.NAME; \
+      p != &profiles.parse && \
+      p != &profiles.search && \
+      p != &profiles.simplify) break; \
+  profs[n++] = p; \
 } while (0);
   PROFILES
 #undef PROFILE
diff --git a/src/profile.hpp b/src/profile.hpp
index c1afe27b..720fee24 100644
--- a/src/profile.hpp
+++ b/src/profile.hpp
@@ -104,41 +104,59 @@ struct Profiles {
 
 }
 
+#define NON_QUIET_PROFILE_CODE(CODE) CODE
+
+#else // !defined(QUIET)
+
+#define NON_QUIET_PROFILE_CODE(CODE) /**/
+
+#endif
+
 /*------------------------------------------------------------------------*/
 
-// Macros for Profiling support.
+// Macros for Profiling support and checking and changing the mode.
 
 #define START(P) \
 do { \
-  if (internal->profiles.P.level > internal->opts.profile) break; \
-  internal->start_profiling (internal->profiles.P, internal->time ()); \
+  NON_QUIET_PROFILE_CODE ( \
+    if (internal->profiles.P.level <= internal->opts.profile) \
+      internal->start_profiling (internal->profiles.P, internal->time ()); \
+  ) \
 } while (0)
 
 #define STOP(P) \
 do { \
-  if (internal->profiles.P.level > internal->opts.profile) break; \
-  internal->stop_profiling (internal->profiles.P, internal->time ()); \
+  NON_QUIET_PROFILE_CODE ( \
+    if (internal->profiles.P.level <= internal->opts.profile) \
+      internal->stop_profiling (internal->profiles.P, internal->time ()); \
+  ) \
 } while (0)
 
 /*------------------------------------------------------------------------*/
 
 #define START_SIMPLIFIER(S,M) \
 do { \
-  const double N = time (); \
-  const int L = internal->opts.profile; \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+  ) \
   if (!preprocessing && !lookingahead) { \
-    if (stable && internal->profiles.stable.level <= L) \
-      internal->stop_profiling (internal->profiles.stable, N); \
-    if (!stable && internal->profiles.unstable.level <= L) \
-      internal->stop_profiling (internal->profiles.unstable, N); \
-    if (internal->profiles.search.level <= L) \
-      internal->stop_profiling (internal->profiles.search, N); \
+    NON_QUIET_PROFILE_CODE ( \
+      if (stable && internal->profiles.stable.level <= L) \
+	internal->stop_profiling (internal->profiles.stable, N); \
+      if (!stable && internal->profiles.unstable.level <= L) \
+	internal->stop_profiling (internal->profiles.unstable, N); \
+      if (internal->profiles.search.level <= L) \
+	internal->stop_profiling (internal->profiles.search, N); \
+    ) \
     reset_mode (SEARCH); \
   } \
-  if (internal->profiles.simplify.level <= L) \
-    internal->start_profiling (internal->profiles.simplify, N); \
-  if (internal->profiles.S.level <= L) \
-    internal->start_profiling (internal->profiles.S, N); \
+  NON_QUIET_PROFILE_CODE ( \
+    if (internal->profiles.simplify.level <= L) \
+      internal->start_profiling (internal->profiles.simplify, N); \
+    if (internal->profiles.S.level <= L) \
+      internal->start_profiling (internal->profiles.S, N); \
+  ) \
   set_mode (SIMPLIFY); \
   set_mode (M); \
 } while (0)
@@ -147,21 +165,25 @@ do { \
 
 #define STOP_SIMPLIFIER(S,M) \
 do { \
-  const double N = time (); \
-  const int L = internal->opts.profile; \
-  if (internal->profiles.S.level <= L) \
-    internal->stop_profiling (internal->profiles.S, N); \
-  if (internal->profiles.simplify.level <= L) \
-    internal->stop_profiling (internal->profiles.simplify, N); \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+    if (internal->profiles.S.level <= L) \
+      internal->stop_profiling (internal->profiles.S, N); \
+    if (internal->profiles.simplify.level <= L) \
+      internal->stop_profiling (internal->profiles.simplify, N); \
+  ) \
   reset_mode (M); \
   reset_mode (SIMPLIFY); \
   if (!preprocessing && !lookingahead) { \
-    if (internal->profiles.search.level <= L) \
-      internal->start_profiling (internal->profiles.search, N); \
-    if (stable && internal->profiles.stable.level <= L) \
-      internal->start_profiling (internal->profiles.stable, N); \
-    if (!stable && internal->profiles.unstable.level <= L) \
-      internal->start_profiling (internal->profiles.unstable, N); \
+    NON_QUIET_PROFILE_CODE ( \
+      if (internal->profiles.search.level <= L) \
+	internal->start_profiling (internal->profiles.search, N); \
+      if (stable && internal->profiles.stable.level <= L) \
+	internal->start_profiling (internal->profiles.stable, N); \
+      if (!stable && internal->profiles.unstable.level <= L) \
+	internal->start_profiling (internal->profiles.unstable, N); \
+    ) \
     set_mode (SEARCH); \
   } \
 } while (0)
@@ -173,14 +195,16 @@ do { \
 do { \
   require_mode (SEARCH); \
   assert (!preprocessing); \
-  const double N = time (); \
-  const int L = internal->opts.profile; \
-  if (stable && internal->profiles.stable.level <= L) \
-    internal->stop_profiling (internal->profiles.stable, N); \
-  if (!stable && internal->profiles.unstable.level <= L) \
-    internal->stop_profiling (internal->profiles.unstable, N); \
-  if (internal->profiles.walk.level <= L) \
-    internal->start_profiling (internal->profiles.walk, N); \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+    if (stable && internal->profiles.stable.level <= L) \
+      internal->stop_profiling (internal->profiles.stable, N); \
+    if (!stable && internal->profiles.unstable.level <= L) \
+      internal->stop_profiling (internal->profiles.unstable, N); \
+    if (internal->profiles.walk.level <= L) \
+      internal->start_profiling (internal->profiles.walk, N); \
+  ) \
   set_mode (WALK); \
 } while (0)
 
@@ -192,14 +216,16 @@ do { \
   require_mode (SEARCH); \
   assert (!preprocessing); \
   reset_mode (WALK); \
-  const double N = time (); \
-  const int L = internal->opts.profile; \
-  if (internal->profiles.walk.level <= L) \
-    internal->stop_profiling (internal->profiles.walk, N); \
-  if (stable && internal->profiles.stable.level <= L) \
-    internal->start_profiling (internal->profiles.stable, N); \
-  if (!stable && internal->profiles.unstable.level <= L) \
-    internal->start_profiling (internal->profiles.unstable, N); \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+    if (internal->profiles.walk.level <= L) \
+      internal->stop_profiling (internal->profiles.walk, N); \
+    if (stable && internal->profiles.stable.level <= L) \
+      internal->start_profiling (internal->profiles.stable, N); \
+    if (!stable && internal->profiles.unstable.level <= L) \
+      internal->start_profiling (internal->profiles.unstable, N); \
+  ) \
 } while (0)
 
 /*------------------------------------------------------------------------*/
@@ -209,7 +235,9 @@ do { \
 do { \
   require_mode (SEARCH); \
   assert (!preprocessing); \
-  START (walk); \
+  NON_QUIET_PROFILE_CODE ( \
+    START (walk); \
+  ) \
   set_mode (WALK); \
 } while (0)
 
@@ -221,27 +249,9 @@ do { \
   require_mode (SEARCH); \
   assert (!preprocessing); \
   reset_mode (WALK); \
-  STOP (walk); \
+  NON_QUIET_PROFILE_CODE ( \
+    STOP (walk); \
+  ) \
 } while (0)
 
-/*------------------------------------------------------------------------*/
-#else // ifndef QUIET
-/*------------------------------------------------------------------------*/
-
-#define START(...) do { } while (0)
-#define STOP(...) do { } while (0)
-
-#define START_SIMPLIFIER(...) do { } while (0)
-#define STOP_SIMPLIFIER(...) do { } while (0)
-
-#define START_OUTER_WALK(...) do { } while (0)
-#define STOP_OUTER_WALK(...) do { } while (0)
-
-#define START_INNER_WALK(...) do { } while (0)
-#define STOP_INNER_WALK(...) do { } while (0)
-
-/*------------------------------------------------------------------------*/
-#endif // ifndef QUIET
-/*------------------------------------------------------------------------*/
-
 #endif // ifndef _profiles_h_INCLUDED
diff --git a/src/random.hpp b/src/random.hpp
index a371347f..594c9836 100644
--- a/src/random.hpp
+++ b/src/random.hpp
@@ -22,6 +22,11 @@ class Random {
   Random (uint64_t seed) : state (seed) { }
   Random (const Random & other) : state (other.seed ()) { }
 
+  // Without this explicit default copy assignment operator declaration GCC
+  // 9.3.0 issues a warning (C++11 semantics but not checked before GCC 9).
+  //
+  Random & operator = (const Random &) = default;
+
   void operator += (uint64_t a) { add (a); }
   uint64_t seed () const { return state; }
 
diff --git a/src/solver.cpp b/src/solver.cpp
index 49bfa695..d53cdb72 100644
--- a/src/solver.cpp
+++ b/src/solver.cpp
@@ -1089,13 +1089,14 @@ class ClauseWriter : public ClauseIterator {
 const char * Solver::write_dimacs (const char * path, int min_max_var) {
   LOG_API_CALL_BEGIN ("write_dimacs", path, min_max_var);
   REQUIRE_VALID_STATE ();
+#ifndef QUIET
+  const double start = internal->time ();
+#endif
+  internal->restore_clauses ();
   ClauseCounter counter;
   (void) traverse_clauses (counter);
   LOG ("found maximal variable %d and %" PRId64 " clauses",
     counter.vars, counter.clauses);
-#ifndef QUIET
-  const double start = internal->time ();
-#endif
   File * file = File::write (internal, path);
   const char * res = 0;
   if (file) {
diff --git a/src/version.cpp b/src/version.cpp
index 7db0994f..a6a5b9d6 100644
--- a/src/version.cpp
+++ b/src/version.cpp
@@ -20,7 +20,7 @@
 
 #ifndef NBUILD
 #ifndef VERSION
-#  define VERSION "sc2020"
+#  define VERSION "1.3.0"
 #endif // NBUILD
 #endif // VERSION
 
diff --git a/src/vivify.cpp b/src/vivify.cpp
index 351b88b7..2af78402 100644
--- a/src/vivify.cpp
+++ b/src/vivify.cpp
@@ -286,11 +286,11 @@ struct vivify_flush_smaller {
   bool operator () (Clause * a, Clause * b) const {
 
     const auto eoa = a->end (), eob = b->end ();
-    auto j = b->begin ();
-    for (auto i = a->begin (); i != eoa && j != eob; i++, j++)
+    auto i = a->begin (), j = b->begin ();
+    for (; i != eoa && j != eob; i++, j++)
       if (*i != *j) return *i < *j;
 
-    return j == eob;
+    return j == eob && i != eoa;
   }
 };
 
diff --git a/test/api/run.sh b/test/api/run.sh
index 406a54b9..b270184a 100755
--- a/test/api/run.sh
+++ b/test/api/run.sh
@@ -3,12 +3,12 @@
 #--------------------------------------------------------------------------#
 
 die () {
-  echo "${HIDE}test/api/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  cecho "${HIDE}test/api/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
   exit 1
 }
 
 msg () {
-  echo "${HIDE}test/api/run.sh:${NORMAL} $*"
+  cecho "${HIDE}test/api/run.sh:${NORMAL} $*"
 }
 
 for dir in . .. ../..
@@ -31,11 +31,11 @@ die "needs to be called from a top-level sub-directory of CaDiCaL"
 [ -f "$CADICALBUILD/libcadical.a" ] || \
   die "can not find '$CADICALBUILD/libcadical.a' (run 'make' first)"
 
-echo -n "$HILITE"
-echo "---------------------------------------------------------"
-echo "API testing in '$CADICALBUILD'"
-echo "---------------------------------------------------------"
-echo -n "$NORMAL"
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "API testing in '$CADICALBUILD'"
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
 
 make -C $CADICALBUILD
 res=$?
@@ -62,7 +62,7 @@ failed=0
 
 cmd () {
   test $status = 1 && return
-  echo $*
+  cecho $*
   $* >> $name.log
   status=$?
 }
@@ -90,10 +90,10 @@ run () {
   cmd $name
   if test $status = 0
   then
-    echo "# 0 ... ${GOOD}ok${NORMAL} (zero exit code)"
+    cecho "# 0 ... ${GOOD}ok${NORMAL} (zero exit code)"
     ok=`expr $ok + 1`
   else
-    echo "# 0 ... ${BAD}failed${NORMAL} (non-zero exit code)"
+    cecho "# 0 ... ${BAD}failed${NORMAL} (non-zero exit code)"
     failed=`expr $failed + 1`
   fi
 }
diff --git a/test/cnf/run.sh b/test/cnf/run.sh
index 7ccf6cc4..289bb4d0 100755
--- a/test/cnf/run.sh
+++ b/test/cnf/run.sh
@@ -3,12 +3,12 @@
 #--------------------------------------------------------------------------#
 
 die () {
-  echo "${HIDE}test/cnf/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  cecho "${HIDE}test/cnf/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
   exit 1
 }
 
 msg () {
-  echo "${HIDE}test/cnf/run.sh:${NORMAL} $*"
+  cecho "${HIDE}test/cnf/run.sh:${NORMAL} $*"
 }
 
 for dir in . .. ../..
@@ -28,11 +28,11 @@ die "needs to be called from a top-level sub-directory of CaDiCaL"
 [ -x "$CADICALBUILD/cadical" ] || \
   die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
 
-echo -n "$HILITE"
-echo "---------------------------------------------------------"
-echo "CNF testing in '$CADICALBUILD'" 
-echo "---------------------------------------------------------"
-echo -n "$NORMAL"
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "CNF testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
 
 make -C $CADICALBUILD
 res=$?
@@ -52,7 +52,7 @@ then
   if [ ! -f $solutionchecker -o ../test/cnf/precochk.c -nt $solutionchecker ]
   then
     cmd="cc -O -o $solutionchecker ../test/cnf/precochk.c -lz"
-    echo "$cmd"
+    cecho "$cmd"
     if $cmd 2>/dev/null
     then
       msg "external solution checking with '$solutionchecker'"
@@ -107,58 +107,58 @@ core () {
     proofopts=" $prf"
   fi
   opts="$cnf --check$solopts$proofopts"
-  echo "$coresolver \\"
-  echo "$opts"
-  echo -n "# $2 ..."
+  cecho "$coresolver \\"
+  cecho "$opts"
+  cecho -n "# $2 ..."
   "$coresolver" $opts 1>$log 2>$err
   res=$?
   if [ ! $res = $2 ] 
   then
-    echo " ${BAD}FAILED${NORMAL} (actual exit code $res)"
+    cecho " ${BAD}FAILED${NORMAL} (actual exit code $res)"
     failed=`expr $failed + 1`
   elif [ $res = 10 ]
   then
     if [ "$solopts" = "" ]
     then
-      echo " ${GOOD}ok${NORMAL} (without solution file)"
+      cecho " ${GOOD}ok${NORMAL} (without solution file)"
     else
-      echo " ${GOOD}ok${NORMAL} (solution file checked after parsing)"
+      cecho " ${GOOD}ok${NORMAL} (solution file checked after parsing)"
     fi
     if [ x"$solutionchecker" = xnone ]
     then
 	ok=`expr $ok + 1`
     else
-      echo "$solutionchecker \\"
-      echo "$cnf $log"
-      echo -n "# 0 ..."
+      cecho "$solutionchecker \\"
+      cecho "$cnf $log"
+      cecho -n "# 0 ..."
       if $solutionchecker $cnf $log 1>&2 >$chk
       then
-        echo " ${GOOD}ok${NORMAL} (solution checked externally too)"
+        cecho " ${GOOD}ok${NORMAL} (solution checked externally too)"
 	ok=`expr $ok + 1`
       else
-	echo " ${BAD}FAILED${NORMAL} (incorrect solution)"
+	cecho " ${BAD}FAILED${NORMAL} (incorrect solution)"
 	failed=`expr $failed + 1`
       fi
     fi
   elif [ $res = 20 ]
   then
-    echo " ${GOOD}ok${NORMAL} (exit code as expected)"
+    cecho " ${GOOD}ok${NORMAL} (exit code as expected)"
     if [ ! x"$proofchecker" = xnone ]
     then
-      echo "$proofchecker \\"
-      echo "$cnf $prf"
-      echo -n "# 0 ..."
+      cecho "$proofchecker \\"
+      cecho "$cnf $prf"
+      cecho -n "# 0 ..."
       if $proofchecker $cnf $prf 1>&2 >$chk
       then
-	echo " ${GOOD}ok${NORMAL} (proof checked)"
+	cecho " ${GOOD}ok${NORMAL} (proof checked)"
 	ok=`expr $ok + 1`
       else
-	echo " ${BAD}FAILED${NORMAL} (proof check '$proofchecker $cnf $prf' failed)"
+	cecho " ${BAD}FAILED${NORMAL} (proof check '$proofchecker $cnf $prf' failed)"
 	failed=`expr $failed + 1`
       fi
     fi
   else 
-    echo " ${BAD}FAILED${NORMAL} (unsupported exit code $res)"
+    cecho " ${BAD}FAILED${NORMAL} (unsupported exit code $res)"
     failed=`expr $failed + 1`
   fi
 }
@@ -171,31 +171,31 @@ simp () {
   err=$prefix-$1.err
   chk=$prefix-$1.chk
   opts="$cnf"
-  echo "$simpsolver \\"
-  echo "$opts"
-  echo -n "# $2 ..."
+  cecho "$simpsolver \\"
+  cecho "$opts"
+  cecho -n "# $2 ..."
   "$simpsolver" $opts 1>$log 2>$err
   res=$?
   if [ ! $res = $2 ] 
   then
-    echo " ${BAD}FAILED${NORMAL} (actual exit code $res)"
+    cecho " ${BAD}FAILED${NORMAL} (actual exit code $res)"
     failed=`expr $failed + 1`
   elif [ $res = 10 ]
   then
-    echo " ${GOOD}ok${NORMAL}"
+    cecho " ${GOOD}ok${NORMAL}"
     if [ x"$solutionchecker" = xnone ]
     then
 	ok=`expr $ok + 1`
     else
-      echo "$solutionchecker \\"
-      echo "$cnf $log"
-      echo -n "# 0 ..."
+      cecho "$solutionchecker \\"
+      cecho "$cnf $log"
+      cecho -n "# 0 ..."
       if $solutionchecker $cnf $log 1>&2 >$chk
       then
-        echo " ${GOOD}ok${NORMAL} (solution checked externally)"
+        cecho " ${GOOD}ok${NORMAL} (solution checked externally)"
 	ok=`expr $ok + 1`
       else
-	echo " ${BAD}FAILED${NORMAL} (incorrect solution)"
+	cecho " ${BAD}FAILED${NORMAL} (incorrect solution)"
 	failed=`expr $failed + 1`
       fi
     fi
diff --git a/test/icnf/run.sh b/test/icnf/run.sh
index be0ce170..082ef203 100755
--- a/test/icnf/run.sh
+++ b/test/icnf/run.sh
@@ -3,12 +3,12 @@
 #--------------------------------------------------------------------------#
 
 die () {
-  echo "${HIDE}test/icnf/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  cecho "${HIDE}test/icnf/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
   exit 1
 }
 
 msg () {
-  echo "${HIDE}test/icnf/run.sh:${NORMAL} $*"
+  cecho "${HIDE}test/icnf/run.sh:${NORMAL} $*"
 }
 
 for dir in . .. ../..
@@ -28,11 +28,11 @@ die "needs to be called from a top-level sub-directory of CaDiCaL"
 [ -x "$CADICALBUILD/cadical" ] || \
   die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
 
-echo -n "$HILITE"
-echo "---------------------------------------------------------"
-echo "ICNF testing in '$CADICALBUILD'" 
-echo "---------------------------------------------------------"
-echo -n "$NORMAL"
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "ICNF testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
 
 make -C $CADICALBUILD
 res=$?
@@ -55,17 +55,17 @@ run () {
   err=$prefix-$1.err
   opts="$icnf --check"
   opts="$icnf"
-  echo "$solver \\"
-  echo "$opts"
-  echo -n "# $2 ..."
+  cecho "$solver \\"
+  cecho "$opts"
+  cecho -n "# $2 ..."
   "$solver" $opts 1>$log 2>$err
   res=$?
   if [ ! $res = $2 ] 
   then
-    echo " ${BAD}FAILED${NORMAL} (actual exit code $res)"
+    cecho " ${BAD}FAILED${NORMAL} (actual exit code $res)"
     failed=`expr $failed + 1`
   else
-    echo " ${GOOD}ok${NORMAL} (exit code '$res' as expected)"
+    cecho " ${GOOD}ok${NORMAL} (exit code '$res' as expected)"
     ok=`expr $ok + 1`
   fi
 }
diff --git a/test/mbt/run.sh b/test/mbt/run.sh
index 05fdb3da..33354c5f 100755
--- a/test/mbt/run.sh
+++ b/test/mbt/run.sh
@@ -3,12 +3,12 @@
 #--------------------------------------------------------------------------#
 
 die () {
-  echo "${HIDE}test/mbt/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  cecho "${HIDE}test/mbt/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
   exit 1
 }
 
 msg () {
-  echo "${HIDE}test/mbt/run.sh:${NORMAL} $*"
+  cecho "${HIDE}test/mbt/run.sh:${NORMAL} $*"
 }
 
 for dir in . .. ../..
@@ -28,11 +28,11 @@ die "needs to be called from a top-level sub-directory of CaDiCaL"
 [ -x "$CADICALBUILD/cadical" ] || \
   die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
 
-echo -n "$HILITE"
-echo "---------------------------------------------------------"
-echo "Model-Based Testing in '$CADICALBUILD'" 
-echo "---------------------------------------------------------"
-echo -n "$NORMAL"
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "Model-Based Testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
 
 make -C $CADICALBUILD
 res=$?
@@ -47,7 +47,7 @@ msg "changing to build directory '$CADICALBUILD' and running"
 cd $CADICALBUILD
 
 cmd="./mobical 42 --medium -L $tests --do-not-fork"
-echo "${HILITE}$cmd${NORMAL}"
+cecho "${HILITE}$cmd${NORMAL}"
 $cmd
 res=$?
 
diff --git a/test/trace/run.sh b/test/trace/run.sh
index cc1269c1..de15ef8d 100755
--- a/test/trace/run.sh
+++ b/test/trace/run.sh
@@ -1,12 +1,12 @@
 #!/bin/sh
 
 die () {
-  echo "${HIDE}test/trace/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  cecho "${HIDE}test/trace/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
   exit 1
 }
 
 msg () {
-  echo "${HIDE}test/trace/run.sh:${NORMAL} $*"
+  cecho "${HIDE}test/trace/run.sh:${NORMAL} $*"
 }
 
 for dir in . .. ../..
@@ -26,11 +26,11 @@ die "needs to be called from a top-level sub-directory of CaDiCaL"
 [ -x "$CADICALBUILD/cadical" ] || \
   die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
 
-echo -n "$HILITE"
-echo "---------------------------------------------------------"
-echo "Regression Testing API traces in '$CADICALBUILD'" 
-echo "---------------------------------------------------------"
-echo -n "$NORMAL"
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "Regression Testing API traces in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
 
 cd $CADICALBUILD || exit 1
 make
@@ -48,16 +48,16 @@ run () {
   msg "running ${HILITE}'$1'${NORMAL}"
   trace=../test/trace/$1.trace
   executed=`expr $executed + 1`
-  echo "$CADICALBUILD/mobical $trace"
+  cecho "$CADICALBUILD/mobical $trace"
   $CADICALBUILD/mobical $trace 2>/dev/null 1>/dev/null
   res=$?
-  echo $res
+  cecho $res
   if [ $res = 0 ]
   then
-    echo "# ... ${GOOD}ok${NORMAL}"
+    cecho "# ... ${GOOD}ok${NORMAL}"
     ok=`expr $ok + 1`
   else
-    echo "# ... ${BAD}failed${NORMAL}"
+    cecho "# ... ${BAD}failed${NORMAL}"
     failed=`expr $failed + 1`
   fi
 }
diff --git a/test/usage/run.sh b/test/usage/run.sh
index 32535873..03b1f1d9 100755
--- a/test/usage/run.sh
+++ b/test/usage/run.sh
@@ -3,12 +3,12 @@
 #--------------------------------------------------------------------------#
 
 die () {
-  echo "${HIDE}test/usage/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  cecho "${HIDE}test/usage/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
   exit 1
 }
 
 msg () {
-  echo "${HIDE}test/usage/run.sh:${NORMAL} $*"
+  cecho "${HIDE}test/usage/run.sh:${NORMAL} $*"
 }
 
 for dir in . .. ../..
@@ -28,11 +28,11 @@ die "needs to be called from a top-level sub-directory of CaDiCaL"
 [ -x "$CADICALBUILD/cadical" ] || \
   die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
 
-echo -n "$HILITE"
-echo "---------------------------------------------------------"
-echo "usage testing in '$CADICALBUILD'" 
-echo "---------------------------------------------------------"
-echo -n "$NORMAL"
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "usage testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
 
 make -C $CADICALBUILD
 res=$?
@@ -44,7 +44,7 @@ solver="$CADICALBUILD/cadical"
 
 #--------------------------------------------------------------------------#
 
-echo "starting test run `pwd`"
+cecho "starting test run `pwd`"
 
 ok=0
 failed=0
@@ -58,15 +58,15 @@ run () {
   log="$buildprefix.log"
   err="$buildprefix.err"
   cmd="$solver $options"
-  echo -n "$cmd"
+  cecho -n "$cmd"
   $cmd 1>$log 2>$err
   res=$?
   if [ $res = $expected ]
   then
-    echo " # ${GOOD}ok${NORMAL} (expected exit code '$res')"
+    cecho " # ${GOOD}ok${NORMAL} (expected exit code '$res')"
     ok=`expr $ok + 1`
   else
-    echo " # ${BAD}FAILED${NORMAL} (unexpected exit code '$res')"
+    cecho " # ${BAD}FAILED${NORMAL} (unexpected exit code '$res')"
     failed=`expr $failed + 1`
   fi
 }